def cont() -> None:
            try:
                ret = f(*args, **kwargs)
            except Exception as e:
                with suppress(InvalidStateError):
                    fut.set_exception(e)
            else:
                with suppress(InvalidStateError):
                    fut.set_result(ret)

            

Reported by Pylint.

              from concurrent.futures import Executor, Future, InvalidStateError
from contextlib import suppress
from queue import SimpleQueue
from typing import Any, Callable, TypeVar, cast

T = TypeVar("T")


class SingleThreadExecutor:

            

Reported by Pylint.

              from queue import SimpleQueue
from typing import Any, Callable, TypeVar, cast

T = TypeVar("T")


class SingleThreadExecutor:
    def __init__(self, pool: Executor) -> None:
        self._q: SimpleQueue = SimpleQueue()

            

Reported by Pylint.

              T = TypeVar("T")


class SingleThreadExecutor:
    def __init__(self, pool: Executor) -> None:
        self._q: SimpleQueue = SimpleQueue()
        pool.submit(self._forever)

    def _forever(self) -> None:

            

Reported by Pylint.

              T = TypeVar("T")


class SingleThreadExecutor:
    def __init__(self, pool: Executor) -> None:
        self._q: SimpleQueue = SimpleQueue()
        pool.submit(self._forever)

    def _forever(self) -> None:

            

Reported by Pylint.

              
    def _forever(self) -> None:
        while True:
            f = self._q.get()
            f()

    def submit(self, f: Callable[..., T], *args: Any, **kwargs: Any) -> T:
        fut: Future = Future()


            

Reported by Pylint.

                          f = self._q.get()
            f()

    def submit(self, f: Callable[..., T], *args: Any, **kwargs: Any) -> T:
        fut: Future = Future()

        def cont() -> None:
            try:
                ret = f(*args, **kwargs)

            

Reported by Pylint.

                          f = self._q.get()
            f()

    def submit(self, f: Callable[..., T], *args: Any, **kwargs: Any) -> T:
        fut: Future = Future()

        def cont() -> None:
            try:
                ret = f(*args, **kwargs)

            

Reported by Pylint.

                      def cont() -> None:
            try:
                ret = f(*args, **kwargs)
            except Exception as e:
                with suppress(InvalidStateError):
                    fut.set_exception(e)
            else:
                with suppress(InvalidStateError):
                    fut.set_result(ret)

            

Reported by Pylint.

              from pathlib import Path, PurePath
from typing import Iterator, Optional

from std2.asyncio import run_in_executor

from ..lang import LANG
from ..shared.types import Doc

_KB = 1000

            

Reported by Pylint.

              
from std2.asyncio import run_in_executor

from ..lang import LANG
from ..shared.types import Doc

_KB = 1000
_HOME = Path.home()


            

Reported by Pylint.

              from std2.asyncio import run_in_executor

from ..lang import LANG
from ..shared.types import Doc

_KB = 1000
_HOME = Path.home()



            

Reported by Pylint.

              from contextlib import suppress
from itertools import islice
from locale import strxfrm
from os import linesep, sep
from os.path import normcase
from pathlib import Path, PurePath
from typing import Iterator, Optional

from std2.asyncio import run_in_executor

            

Reported by Pylint.

              _HOME = Path.home()


def show_path(cwd: PurePath, path: PurePath, is_dir: bool) -> str:
    posfix = sep if is_dir else ""
    with suppress(ValueError):
        rel = path.relative_to(cwd)
        return f".{sep}{normcase(rel)}{posfix}"


            

Reported by Pylint.

              
async def _show_file(path: Path, ellipsis: str, height: int) -> Doc:
    def lines() -> Iterator[str]:
        with path.open("r") as fd:
            lines = fd.readlines(_KB)
        lit = islice((line.rstrip() for line in lines), height)
        for idx, line in enumerate(lit, start=1):
            if idx >= height and len(lines) > height:
                yield ellipsis

            

Reported by Pylint.

                      except UnicodeDecodeError:
            text = LANG("file binary")

        t = text or LANG("file empty")
        doc = Doc(text=t, syntax="")
        return doc

    return await run_in_executor(cont)


            

Reported by Pylint.

                  return await run_in_executor(cont)


async def show(cwd: PurePath, path: Path, ellipsis: str, height: int) -> Optional[Doc]:
    try:
        if path.is_dir():
            return await _show_dir(cwd, path=path, ellipsis=ellipsis, height=height)
        elif path.is_file():
            return await _show_file(path, ellipsis=ellipsis, height=height)

            

Reported by Pylint.

              
async def show(cwd: PurePath, path: Path, ellipsis: str, height: int) -> Optional[Doc]:
    try:
        if path.is_dir():
            return await _show_dir(cwd, path=path, ellipsis=ellipsis, height=height)
        elif path.is_file():
            return await _show_file(path, ellipsis=ellipsis, height=height)
        else:
            return None

            

Reported by Pylint.

              from random import uniform
from unittest import TestCase

from ...coq.server.reviewer import sigmoid


class Sigmoid(TestCase):
    def test_1(self) -> None:
        y = sigmoid(0)

            

Reported by Pylint.

              from random import uniform
from unittest import TestCase

from ...coq.server.reviewer import sigmoid


class Sigmoid(TestCase):
    def test_1(self) -> None:
        y = sigmoid(0)

            

Reported by Pylint.

              from ...coq.server.reviewer import sigmoid


class Sigmoid(TestCase):
    def test_1(self) -> None:
        y = sigmoid(0)
        self.assertEqual(y, 1)

    def test_2(self) -> None:

            

Reported by Pylint.

              

class Sigmoid(TestCase):
    def test_1(self) -> None:
        y = sigmoid(0)
        self.assertEqual(y, 1)

    def test_2(self) -> None:
        for _ in range(0, 10000):

            

Reported by Pylint.

              
class Sigmoid(TestCase):
    def test_1(self) -> None:
        y = sigmoid(0)
        self.assertEqual(y, 1)

    def test_2(self) -> None:
        for _ in range(0, 10000):
            y = sigmoid(uniform(-10, 10))

            

Reported by Pylint.

                      y = sigmoid(0)
        self.assertEqual(y, 1)

    def test_2(self) -> None:
        for _ in range(0, 10000):
            y = sigmoid(uniform(-10, 10))
            self.assertTrue(y >= 0.5 and y <= 1.5)

            

Reported by Pylint.

              
    def test_2(self) -> None:
        for _ in range(0, 10000):
            y = sigmoid(uniform(-10, 10))
            self.assertTrue(y >= 0.5 and y <= 1.5)

            

Reported by Pylint.

              
    def test_2(self) -> None:
        for _ in range(0, 10000):
            y = sigmoid(uniform(-10, 10))
            self.assertTrue(y >= 0.5 and y <= 1.5)

            

Reported by Bandit.

                  def test_2(self) -> None:
        for _ in range(0, 10000):
            y = sigmoid(uniform(-10, 10))
            self.assertTrue(y >= 0.5 and y <= 1.5)

            

Reported by Pylint.

              from contextlib import contextmanager
from typing import Any, Iterator, MutableMapping, Optional, Tuple

from pynvim_pp.logging import log
from std2.locale import si_prefixed_smol
from std2.timeit import timeit as _timeit

from ..consts import DEBUG


            

Reported by Pylint.

              from typing import Any, Iterator, MutableMapping, Optional, Tuple

from pynvim_pp.logging import log
from std2.locale import si_prefixed_smol
from std2.timeit import timeit as _timeit

from ..consts import DEBUG

_RECORDS: MutableMapping[str, Tuple[int, float]] = {}

            

Reported by Pylint.

              
from pynvim_pp.logging import log
from std2.locale import si_prefixed_smol
from std2.timeit import timeit as _timeit

from ..consts import DEBUG

_RECORDS: MutableMapping[str, Tuple[int, float]] = {}


            

Reported by Pylint.

              from std2.locale import si_prefixed_smol
from std2.timeit import timeit as _timeit

from ..consts import DEBUG

_RECORDS: MutableMapping[str, Tuple[int, float]] = {}


@contextmanager

            

Reported by Pylint.

              from contextlib import contextmanager
from typing import Any, Iterator, MutableMapping, Optional, Tuple

from pynvim_pp.logging import log
from std2.locale import si_prefixed_smol
from std2.timeit import timeit as _timeit

from ..consts import DEBUG


            

Reported by Pylint.

              

@contextmanager
def timeit(
    name: str, *args: Any, force: bool = False, warn: Optional[float] = None
) -> Iterator[None]:
    if DEBUG or force or warn is not None:
        with _timeit() as t:
            yield None

            

Reported by Pylint.

                  name: str, *args: Any, force: bool = False, warn: Optional[float] = None
) -> Iterator[None]:
    if DEBUG or force or warn is not None:
        with _timeit() as t:
            yield None
        delta = t()
        if DEBUG or delta >= (warn or 0):
            times, cum = _RECORDS.get(name, (0, 0))
            tt, c = times + 1, cum + delta

            

Reported by Pylint.

                      delta = t()
        if DEBUG or delta >= (warn or 0):
            times, cum = _RECORDS.get(name, (0, 0))
            tt, c = times + 1, cum + delta
            _RECORDS[name] = tt, c

            label = name.ljust(50)
            time = f"{si_prefixed_smol(delta, precision=0)}s".ljust(8)
            ttime = f"{si_prefixed_smol(c / tt, precision=0)}s".ljust(8)

            

Reported by Pylint.

                      delta = t()
        if DEBUG or delta >= (warn or 0):
            times, cum = _RECORDS.get(name, (0, 0))
            tt, c = times + 1, cum + delta
            _RECORDS[name] = tt, c

            label = name.ljust(50)
            time = f"{si_prefixed_smol(delta, precision=0)}s".ljust(8)
            ttime = f"{si_prefixed_smol(c / tt, precision=0)}s".ljust(8)

            

Reported by Pylint.

              from pathlib import Path
from typing import Optional, cast

from pynvim import Nvim

from ...lsp.types import CompletionItem
from ...registry import atomic
from ..parse import parse_item
from ..types import Completion

            

Reported by Pylint.

              
from pynvim import Nvim

from ...lsp.types import CompletionItem
from ...registry import atomic
from ..parse import parse_item
from ..types import Completion
from .request import async_request


            

Reported by Pylint.

              from pynvim import Nvim

from ...lsp.types import CompletionItem
from ...registry import atomic
from ..parse import parse_item
from ..types import Completion
from .request import async_request

_LUA = (Path(__file__).resolve().parent / "preview.lua").read_text("UTF-8")

            

Reported by Pylint.

              
from ...lsp.types import CompletionItem
from ...registry import atomic
from ..parse import parse_item
from ..types import Completion
from .request import async_request

_LUA = (Path(__file__).resolve().parent / "preview.lua").read_text("UTF-8")


            

Reported by Pylint.

              from ...lsp.types import CompletionItem
from ...registry import atomic
from ..parse import parse_item
from ..types import Completion
from .request import async_request

_LUA = (Path(__file__).resolve().parent / "preview.lua").read_text("UTF-8")

atomic.exec_lua(_LUA, ())

            

Reported by Pylint.

              from ...registry import atomic
from ..parse import parse_item
from ..types import Completion
from .request import async_request

_LUA = (Path(__file__).resolve().parent / "preview.lua").read_text("UTF-8")

atomic.exec_lua(_LUA, ())


            

Reported by Pylint.

              from pathlib import Path
from typing import Optional, cast

from pynvim import Nvim

from ...lsp.types import CompletionItem
from ...registry import atomic
from ..parse import parse_item
from ..types import Completion

            

Reported by Pylint.

              atomic.exec_lua(_LUA, ())


async def request(nvim: Nvim, item: CompletionItem) -> Optional[Completion]:
    stream = async_request(nvim, "COQlsp_preview", item)
    async for reply in stream:
        if reply:
            break
    else:

            

Reported by Pylint.

                  else:
        reply = None

    if reply:
        resp = cast(CompletionItem, reply)
        return parse_item("", weight_adjust=0, item=resp)
    else:
        return None

            

Reported by Pylint.

              from typing import AsyncIterator

from ...databases.snippets.database import SDB
from ...shared.runtime import Worker as BaseWorker
from ...shared.settings import SnippetClient
from ...shared.types import Completion, Context, Doc, SnippetEdit


class Worker(BaseWorker[SnippetClient, SDB]):

            

Reported by Pylint.

              from typing import AsyncIterator

from ...databases.snippets.database import SDB
from ...shared.runtime import Worker as BaseWorker
from ...shared.settings import SnippetClient
from ...shared.types import Completion, Context, Doc, SnippetEdit


class Worker(BaseWorker[SnippetClient, SDB]):

            

Reported by Pylint.

              
from ...databases.snippets.database import SDB
from ...shared.runtime import Worker as BaseWorker
from ...shared.settings import SnippetClient
from ...shared.types import Completion, Context, Doc, SnippetEdit


class Worker(BaseWorker[SnippetClient, SDB]):
    async def work(self, context: Context) -> AsyncIterator[Completion]:

            

Reported by Pylint.

              from ...databases.snippets.database import SDB
from ...shared.runtime import Worker as BaseWorker
from ...shared.settings import SnippetClient
from ...shared.types import Completion, Context, Doc, SnippetEdit


class Worker(BaseWorker[SnippetClient, SDB]):
    async def work(self, context: Context) -> AsyncIterator[Completion]:
        match = context.words or context.syms

            

Reported by Pylint.

              from typing import AsyncIterator

from ...databases.snippets.database import SDB
from ...shared.runtime import Worker as BaseWorker
from ...shared.settings import SnippetClient
from ...shared.types import Completion, Context, Doc, SnippetEdit


class Worker(BaseWorker[SnippetClient, SDB]):

            

Reported by Pylint.

              from ...shared.types import Completion, Context, Doc, SnippetEdit


class Worker(BaseWorker[SnippetClient, SDB]):
    async def work(self, context: Context) -> AsyncIterator[Completion]:
        match = context.words or context.syms
        snippets = await self._misc.select(
            self._supervisor.options,
            filetype=context.filetype,

            

Reported by Pylint.

              from ...shared.types import Completion, Context, Doc, SnippetEdit


class Worker(BaseWorker[SnippetClient, SDB]):
    async def work(self, context: Context) -> AsyncIterator[Completion]:
        match = context.words or context.syms
        snippets = await self._misc.select(
            self._supervisor.options,
            filetype=context.filetype,

            

Reported by Pylint.

              

class Worker(BaseWorker[SnippetClient, SDB]):
    async def work(self, context: Context) -> AsyncIterator[Completion]:
        match = context.words or context.syms
        snippets = await self._misc.select(
            self._supervisor.options,
            filetype=context.filetype,
            word=match,

            

Reported by Pylint.

              
CREATE TABLE IF NOT EXISTS sources (
  name TEXT NOT NULL PRIMARY KEY
) WITHOUT ROWID;


CREATE TABLE IF NOT EXISTS batches (
  rowid BLOB NOT NULL PRIMARY KEY
) WITHOUT rowid;

            

Reported by SQLint.

              
CREATE TABLE IF NOT EXISTS batches (
  rowid BLOB NOT NULL PRIMARY KEY
) WITHOUT rowid;


CREATE TABLE IF NOT EXISTS instances (
  rowid     BLOB NOT NULL PRIMARY KEY,
  source_id TEXT NOT NULL REFERENCES sources (name)  ON UPDATE CASCADE ON DELETE CASCADE,

            

Reported by SQLint.

                source_id TEXT NOT NULL REFERENCES sources (name)  ON UPDATE CASCADE ON DELETE CASCADE,
  batch_id  BLOB NOT NULL REFERENCES batches (rowid) ON UPDATE CASCADE ON DELETE CASCADE,
  UNIQUE(batch_id, source_id)
) WITHOUT rowid;
CREATE INDEX IF NOT EXISTS instances_batch_id  ON instances (batch_id);
CREATE INDEX IF NOT EXISTS instances_source_id ON instances (source_id);


CREATE TABLE IF NOT EXISTS instance_stats (

            

Reported by SQLint.

              

CREATE TABLE IF NOT EXISTS inserted (
  rowid       INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
  instance_id BLOB    NOT NULL REFERENCES instances (rowid) ON UPDATE CASCADE ON DELETE CASCADE,
  sort_by     TEXT    NOT NULL
);
CREATE INDEX IF NOT EXISTS inserted_instance_id ON inserted (instance_id);
CREATE INDEX IF NOT EXISTS inserted_sort_by     ON inserted (sort_by);

            

Reported by SQLint.

              --


CREATE VIEW IF NOT EXISTS instance_stats_view AS
SELECT
  instances.source_id                     AS source,
  COALESCE(instance_stats.interrupted, 1) AS interrupted,
  instance_stats.duration                 AS duration,
  COALESCE(instance_stats.items, 0)       AS items

            

Reported by SQLint.

                instance_stats.instance_id = instances.rowid;


CREATE VIEW IF NOT EXISTS stats_quantiles_view AS
SELECT
  source                                                 AS source,
  COALESCE(SUM(interrupted), 0)                          AS interrupted,
  COALESCE(AVG(duration), 0)                             AS avg_duration,
  COALESCE(X_QUANTILES(duration, 0, 0.5, 0.95, 1), '{}') AS q_duration,

            

Reported by SQLint.

                source;


CREATE VIEW IF NOT EXISTS stats_inserted_view AS
SELECT
  instances.source_id   AS source,
  COUNT(inserted.rowid) AS inserted
FROM instances
LEFT JOIN inserted

            

Reported by SQLint.

                instances.source_id;


CREATE VIEW IF NOT EXISTS stats_view AS
SELECT
  sources.name                                    AS source,
  COALESCE(stats_quantiles_view.interrupted, 0)   AS interrupted,
  COALESCE(stats_quantiles_view.avg_items, 0)     AS avg_items,
  COALESCE(stats_quantiles_view.q_items, '{}')    AS q_items,

            

Reported by SQLint.

              from itertools import accumulate
from typing import AbstractSet

from .parse import coalesce, is_word, lower
from .types import Context, ContextualEdit, Edit


def _match(lhs: bool, existing: str, insertion: str) -> str:
    existing, insertion = lower(existing), lower(insertion)

            

Reported by Pylint.

              from typing import AbstractSet

from .parse import coalesce, is_word, lower
from .types import Context, ContextualEdit, Edit


def _match(lhs: bool, existing: str, insertion: str) -> str:
    existing, insertion = lower(existing), lower(insertion)
    if lhs:

            

Reported by Pylint.

                      for match in reversed(tuple(accumulate(insertion))):
            if match == existing[-len(match) :]:
                return match
        else:
            return ""
    else:
        for match in reversed(tuple(accumulate(reversed(insertion)))):
            if match == existing[: len(match) :]:
                return match

            

Reported by Pylint.

                      for match in reversed(tuple(accumulate(reversed(insertion)))):
            if match == existing[: len(match) :]:
                return match
        else:
            return ""


def trans(line_before: str, line_after: str, edit: Edit) -> ContextualEdit:
    l_match = _match(True, existing=line_before, insertion=edit.new_text)

            

Reported by Pylint.

              from itertools import accumulate
from typing import AbstractSet

from .parse import coalesce, is_word, lower
from .types import Context, ContextualEdit, Edit


def _match(lhs: bool, existing: str, insertion: str) -> str:
    existing, insertion = lower(existing), lower(insertion)

            

Reported by Pylint.

                          return ""


def trans(line_before: str, line_after: str, edit: Edit) -> ContextualEdit:
    l_match = _match(True, existing=line_before, insertion=edit.new_text)
    rest = edit.new_text[len(l_match) :]
    r_match = _match(False, existing=line_after, insertion=rest)
    c_edit = ContextualEdit(
        new_text=edit.new_text,

            

Reported by Pylint.

                  return c_edit


def trans_adjusted(
    unifying_chars: AbstractSet[str], ctx: Context, edit: Edit
) -> ContextualEdit:
    c_edit = trans(line_before=ctx.line_before, line_after=ctx.line_after, edit=edit)
    new_syms = len(tuple(coalesce(edit.new_text, unifying_chars=unifying_chars)))
    simple_before = (

            

Reported by Pylint.

                  return adjusted


def expand_tabs(context: Context, text: str) -> str:
    new_text = (
        text.expandtabs(context.tabstop)
        if context.expandtab
        else text.replace(" " * context.tabstop, "\t")
    )

            

Reported by Pylint.

              from typing import Awaitable, Callable, Iterator, MutableMapping, Sequence, Tuple
from uuid import UUID, uuid4

from ...shared.runtime import Supervisor
from ...shared.timeit import timeit
from ...shared.types import Completion, Context, Edit, SnippetEdit
from .database import Database



            

Reported by Pylint.

              from uuid import UUID, uuid4

from ...shared.runtime import Supervisor
from ...shared.timeit import timeit
from ...shared.types import Completion, Context, Edit, SnippetEdit
from .database import Database


@dataclass(frozen=True)

            

Reported by Pylint.

              
from ...shared.runtime import Supervisor
from ...shared.timeit import timeit
from ...shared.types import Completion, Context, Edit, SnippetEdit
from .database import Database


@dataclass(frozen=True)
class _CacheCtx:

            

Reported by Pylint.

              from ...shared.runtime import Supervisor
from ...shared.timeit import timeit
from ...shared.types import Completion, Context, Edit, SnippetEdit
from .database import Database


@dataclass(frozen=True)
class _CacheCtx:
    change_id: UUID

            

Reported by Pylint.

                              comps = (self._cached.get(sort_by) for sort_by in words)
                return (c for c in comps if c)

        async def set(completions: Sequence[Completion]) -> None:
            new_comps = {c.sort_by: c for c in map(_trans, completions)}
            await self._db.insert(new_comps.keys())
            self._cached.update(new_comps)

        return use_cache, get(), set

            

Reported by Pylint.

              from dataclasses import dataclass, replace
from typing import Awaitable, Callable, Iterator, MutableMapping, Sequence, Tuple
from uuid import UUID, uuid4

from ...shared.runtime import Supervisor
from ...shared.timeit import timeit
from ...shared.types import Completion, Context, Edit, SnippetEdit
from .database import Database


            

Reported by Pylint.

                  return replace(comp, primary_edit=edit, secondary_edits=())


class CacheWorker:
    def __init__(self, supervisor: Supervisor) -> None:
        self._soup = supervisor
        self._db = Database(supervisor.pool)
        self._cache_ctx = _CacheCtx(
            change_id=uuid4(),

            

Reported by Pylint.

                  return replace(comp, primary_edit=edit, secondary_edits=())


class CacheWorker:
    def __init__(self, supervisor: Supervisor) -> None:
        self._soup = supervisor
        self._db = Database(supervisor.pool)
        self._cache_ctx = _CacheCtx(
            change_id=uuid4(),

            

Reported by Pylint.

              from textwrap import dedent
from typing import AbstractSet, MutableSequence, MutableSet, Sequence, Tuple

from ..types import ParsedSnippet
from .parse import raise_err

_COMMENT_START = "#"
_EXTENDS_START = "extends"
_INCLUDES_START = "include"

            

Reported by Pylint.

              from typing import AbstractSet, MutableSequence, MutableSet, Sequence, Tuple

from ..types import ParsedSnippet
from .parse import raise_err

_COMMENT_START = "#"
_EXTENDS_START = "extends"
_INCLUDES_START = "include"
_SNIPPET_START = "snippet"

            

Reported by Pylint.

              from os import linesep
from os.path import splitext
from pathlib import Path
from string import whitespace
from textwrap import dedent
from typing import AbstractSet, MutableSequence, MutableSet, Sequence, Tuple

from ..types import ParsedSnippet
from .parse import raise_err

            

Reported by Pylint.

              def _start(line: str) -> Tuple[str, str, MutableSet[str]]:
    rest = line[len(_SNIPPET_START) :].strip()
    name, _, label = rest.partition(" ")
    if label.startswith('"') and label[1:].count('"') == 1:
        quoted, _, opts = label[1:].partition('"')
        options = {*opts.strip().split(" ")}
        return name, quoted, options
    else:
        return name, label, set()

            

Reported by Pylint.

                      return name, label, set()


def parse(path: Path) -> Tuple[AbstractSet[str], Sequence[ParsedSnippet]]:
    snippets: MutableSequence[ParsedSnippet] = []
    extends: MutableSet[str] = set()

    current_name = ""
    current_label: str = ""

            

Reported by Pylint.

                      return name, label, set()


def parse(path: Path) -> Tuple[AbstractSet[str], Sequence[ParsedSnippet]]:
    snippets: MutableSequence[ParsedSnippet] = []
    extends: MutableSet[str] = set()

    current_name = ""
    current_label: str = ""

            

Reported by Pylint.

                      return name, label, set()


def parse(path: Path) -> Tuple[AbstractSet[str], Sequence[ParsedSnippet]]:
    snippets: MutableSequence[ParsedSnippet] = []
    extends: MutableSet[str] = set()

    current_name = ""
    current_label: str = ""

            

Reported by Pylint.

                              extends.add(filetype.strip())

        elif line.startswith(_INCLUDES_START):
            ft = line[len(_INCLUDES_START) :].strip()
            filetype, _ = splitext(ft)
            extends.add(filetype)

        elif line.startswith(_SNIPPET_START):
            push()

            

Reported by Pylint.