jaclang 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/importlib/metadata/__init__.pyi

@@ -0,0 +1,285 @@
+import abc
+import pathlib
+import sys
+from _collections_abc import dict_keys, dict_values
+from _typeshed import StrPath
+from collections.abc import Iterable, Iterator, Mapping
+from email.message import Message
+from importlib.abc import MetaPathFinder
+from os import PathLike
+from pathlib import Path
+from re import Pattern
+from typing import Any, ClassVar, Generic, NamedTuple, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+_T = TypeVar("_T")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+__all__ = [
+    "Distribution",
+    "DistributionFinder",
+    "PackageNotFoundError",
+    "distribution",
+    "distributions",
+    "entry_points",
+    "files",
+    "metadata",
+    "requires",
+    "version",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["PackageMetadata", "packages_distributions"]
+
+if sys.version_info >= (3, 10):
+    from importlib.metadata._meta import PackageMetadata as PackageMetadata, SimplePath
+    def packages_distributions() -> Mapping[str, list[str]]: ...
+
+    if sys.version_info >= (3, 12):
+        # It's generic but shouldn't be
+        _SimplePath: TypeAlias = SimplePath[Any]
+    else:
+        _SimplePath: TypeAlias = SimplePath
+else:
+    _SimplePath: TypeAlias = Path
+
+class PackageNotFoundError(ModuleNotFoundError):
+    @property
+    def name(self) -> str: ...  # type: ignore[override]
+
+if sys.version_info >= (3, 11):
+    class DeprecatedTuple:
+        def __getitem__(self, item: int) -> str: ...
+
+    _EntryPointBase = DeprecatedTuple
+else:
+    class _EntryPointBase(NamedTuple):
+        name: str
+        value: str
+        group: str
+
+class EntryPoint(_EntryPointBase):
+    pattern: ClassVar[Pattern[str]]
+    if sys.version_info >= (3, 11):
+        name: str
+        value: str
+        group: str
+
+        def __init__(self, name: str, value: str, group: str) -> None: ...
+
+    def load(self) -> Any: ...  # Callable[[], Any] or an importable module
+    @property
+    def extras(self) -> list[str]: ...
+    if sys.version_info >= (3, 9):
+        @property
+        def module(self) -> str: ...
+        @property
+        def attr(self) -> str: ...
+    if sys.version_info >= (3, 10):
+        dist: ClassVar[Distribution | None]
+        def matches(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> bool: ...  # undocumented
+
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    if sys.version_info >= (3, 11):
+        def __lt__(self, other: object) -> bool: ...
+    if sys.version_info < (3, 12):
+        def __iter__(self) -> Iterator[Any]: ...  # result of iter((str, Self)), really
+
+if sys.version_info >= (3, 12):
+    class EntryPoints(tuple[EntryPoint, ...]):
+        def __getitem__(self, name: str) -> EntryPoint: ...  # type: ignore[override]
+        def select(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> EntryPoints: ...
+        @property
+        def names(self) -> set[str]: ...
+        @property
+        def groups(self) -> set[str]: ...
+
+elif sys.version_info >= (3, 10):
+    class DeprecatedList(list[_T]): ...
+
+    class EntryPoints(DeprecatedList[EntryPoint]):  # use as list is deprecated since 3.10
+        # int argument is deprecated since 3.10
+        def __getitem__(self, name: int | str) -> EntryPoint: ...  # type: ignore[override]
+        def select(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> EntryPoints: ...
+        @property
+        def names(self) -> set[str]: ...
+        @property
+        def groups(self) -> set[str]: ...
+
+if sys.version_info >= (3, 10) and sys.version_info < (3, 12):
+    class Deprecated(Generic[_KT, _VT]):
+        def __getitem__(self, name: _KT) -> _VT: ...
+        @overload
+        def get(self, name: _KT) -> _VT | None: ...
+        @overload
+        def get(self, name: _KT, default: _T) -> _VT | _T: ...
+        def __iter__(self) -> Iterator[_KT]: ...
+        def __contains__(self, *args: object) -> bool: ...
+        def keys(self) -> dict_keys[_KT, _VT]: ...
+        def values(self) -> dict_values[_KT, _VT]: ...
+
+    class SelectableGroups(Deprecated[str, EntryPoints], dict[str, EntryPoints]):  # use as dict is deprecated since 3.10
+        @classmethod
+        def load(cls, eps: Iterable[EntryPoint]) -> Self: ...
+        @property
+        def groups(self) -> set[str]: ...
+        @property
+        def names(self) -> set[str]: ...
+        @overload
+        def select(self) -> Self: ...  # type: ignore[misc]
+        @overload
+        def select(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> EntryPoints: ...
+
+class PackagePath(pathlib.PurePosixPath):
+    def read_text(self, encoding: str = "utf-8") -> str: ...
+    def read_binary(self) -> bytes: ...
+    def locate(self) -> PathLike[str]: ...
+    # The following attributes are not defined on PackagePath, but are dynamically added by Distribution.files:
+    hash: FileHash | None
+    size: int | None
+    dist: Distribution
+
+class FileHash:
+    mode: str
+    value: str
+    def __init__(self, spec: str) -> None: ...
+
+if sys.version_info >= (3, 12):
+    class DeprecatedNonAbstract: ...
+    _distribution_parent = DeprecatedNonAbstract
+else:
+    _distribution_parent = object
+
+class Distribution(_distribution_parent):
+    @abc.abstractmethod
+    def read_text(self, filename: str) -> str | None: ...
+    @abc.abstractmethod
+    def locate_file(self, path: StrPath) -> _SimplePath: ...
+    @classmethod
+    def from_name(cls, name: str) -> Distribution: ...
+    @overload
+    @classmethod
+    def discover(cls, *, context: DistributionFinder.Context) -> Iterable[Distribution]: ...
+    @overload
+    @classmethod
+    def discover(
+        cls, *, context: None = None, name: str | None = ..., path: list[str] = ..., **kwargs: Any
+    ) -> Iterable[Distribution]: ...
+    @staticmethod
+    def at(path: StrPath) -> PathDistribution: ...
+
+    if sys.version_info >= (3, 10):
+        @property
+        def metadata(self) -> PackageMetadata: ...
+        @property
+        def entry_points(self) -> EntryPoints: ...
+    else:
+        @property
+        def metadata(self) -> Message: ...
+        @property
+        def entry_points(self) -> list[EntryPoint]: ...
+
+    @property
+    def version(self) -> str: ...
+    @property
+    def files(self) -> list[PackagePath] | None: ...
+    @property
+    def requires(self) -> list[str] | None: ...
+    if sys.version_info >= (3, 10):
+        @property
+        def name(self) -> str: ...
+
+class DistributionFinder(MetaPathFinder):
+    class Context:
+        name: str | None
+        def __init__(self, *, name: str | None = ..., path: list[str] = ..., **kwargs: Any) -> None: ...
+        @property
+        def path(self) -> list[str]: ...
+
+    @abc.abstractmethod
+    def find_distributions(self, context: DistributionFinder.Context = ...) -> Iterable[Distribution]: ...
+
+class MetadataPathFinder(DistributionFinder):
+    @classmethod
+    def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
+    if sys.version_info >= (3, 10):
+        # Yes, this is an instance method that has a parameter named "cls"
+        def invalidate_caches(cls) -> None: ...
+
+class PathDistribution(Distribution):
+    _path: _SimplePath
+    def __init__(self, path: _SimplePath) -> None: ...
+    def read_text(self, filename: StrPath) -> str | None: ...
+    def locate_file(self, path: StrPath) -> _SimplePath: ...
+
+def distribution(distribution_name: str) -> Distribution: ...
+@overload
+def distributions(*, context: DistributionFinder.Context) -> Iterable[Distribution]: ...
+@overload
+def distributions(
+    *, context: None = None, name: str | None = ..., path: list[str] = ..., **kwargs: Any
+) -> Iterable[Distribution]: ...
+
+if sys.version_info >= (3, 10):
+    def metadata(distribution_name: str) -> PackageMetadata: ...
+
+else:
+    def metadata(distribution_name: str) -> Message: ...
+
+if sys.version_info >= (3, 12):
+    def entry_points(
+        *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
+    ) -> EntryPoints: ...
+
+elif sys.version_info >= (3, 10):
+    @overload
+    def entry_points() -> SelectableGroups: ...  # type: ignore[overload-overlap]
+    @overload
+    def entry_points(
+        *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
+    ) -> EntryPoints: ...
+
+else:
+    def entry_points() -> dict[str, list[EntryPoint]]: ...
+
+def version(distribution_name: str) -> str: ...
+def files(distribution_name: str) -> list[PackagePath] | None: ...
+def requires(distribution_name: str) -> list[str] | None: ...

jaclang/vendor/mypy/typeshed/stdlib/importlib/metadata/_meta.pyi

@@ -0,0 +1,49 @@
+import sys
+from collections.abc import Iterator
+from typing import Any, Protocol, TypeVar, overload
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+
+class PackageMetadata(Protocol):
+    def __len__(self) -> int: ...
+    def __contains__(self, item: str) -> bool: ...
+    def __getitem__(self, key: str) -> str: ...
+    def __iter__(self) -> Iterator[str]: ...
+    @property
+    def json(self) -> dict[str, str | list[str]]: ...
+    @overload
+    def get_all(self, name: str, failobj: None = None) -> list[Any] | None: ...
+    @overload
+    def get_all(self, name: str, failobj: _T) -> list[Any] | _T: ...
+    if sys.version_info >= (3, 12):
+        @overload
+        def get(self, name: str, failobj: None = None) -> str | None: ...
+        @overload
+        def get(self, name: str, failobj: _T) -> _T | str: ...
+
+if sys.version_info >= (3, 12):
+    class SimplePath(Protocol[_T_co]):
+        # At runtime this is defined as taking `str | _T`, but that causes trouble.
+        # See #11436.
+        def joinpath(self, other: str, /) -> _T_co: ...
+        @property
+        def parent(self) -> _T_co: ...
+        def read_text(self) -> str: ...
+        # As with joinpath(), this is annotated as taking `str | _T` at runtime.
+        def __truediv__(self, other: str, /) -> _T_co: ...
+
+else:
+    class SimplePath(Protocol):
+        # Actually takes only self at runtime, but that's clearly wrong
+        def joinpath(self, other: Any, /) -> SimplePath: ...
+        # Not defined as a property at runtime, but it should be
+        @property
+        def parent(self) -> Any: ...
+        def read_text(self) -> str: ...
+        # There was a bug in `SimplePath` definition in cpython, see #8451
+        #  Strictly speaking `__div__` was defined in 3.10, not __truediv__,
+        # but it should have always been `__truediv__`.
+        # Also, the runtime defines this method as taking no arguments,
+        # which is obviously wrong.
+        def __truediv__(self, other: Any, /) -> SimplePath: ...

jaclang/vendor/mypy/typeshed/stdlib/importlib/readers.pyi

@@ -0,0 +1,68 @@
+# On py311+, things are actually defined in importlib.resources.readers,
+# and re-exported here,
+# but doing it this way leads to less code duplication for us
+
+import pathlib
+import sys
+import zipfile
+from _typeshed import Incomplete, StrPath
+from collections.abc import Iterable, Iterator
+from io import BufferedReader
+from typing import Literal, NoReturn, TypeVar
+from typing_extensions import Never
+
+if sys.version_info >= (3, 11):
+    import importlib.resources.abc as abc
+else:
+    import importlib.abc as abc
+
+if sys.version_info >= (3, 10):
+    if sys.version_info >= (3, 11):
+        __all__ = ["FileReader", "ZipReader", "MultiplexedPath", "NamespaceReader"]
+
+    if sys.version_info < (3, 11):
+        _T = TypeVar("_T")
+
+        def remove_duplicates(items: Iterable[_T]) -> Iterator[_T]: ...
+
+    class FileReader(abc.TraversableResources):
+        path: pathlib.Path
+        def __init__(self, loader) -> None: ...
+        def resource_path(self, resource: StrPath) -> str: ...
+        def files(self) -> pathlib.Path: ...
+
+    class ZipReader(abc.TraversableResources):
+        prefix: str
+        archive: Incomplete
+        def __init__(self, loader, module: str) -> None: ...
+        def open_resource(self, resource: str) -> BufferedReader: ...
+        def is_resource(self, path: StrPath) -> bool: ...
+        def files(self) -> zipfile.Path: ...
+
+    class MultiplexedPath(abc.Traversable):
+        def __init__(self, *paths: abc.Traversable) -> None: ...
+        def iterdir(self) -> Iterator[abc.Traversable]: ...
+        def read_bytes(self) -> NoReturn: ...
+        def read_text(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+        def is_dir(self) -> Literal[True]: ...
+        def is_file(self) -> Literal[False]: ...
+
+        if sys.version_info >= (3, 12):
+            def joinpath(self, *descendants: str) -> abc.Traversable: ...
+        elif sys.version_info >= (3, 11):
+            def joinpath(self, child: str) -> abc.Traversable: ...  # type: ignore[override]
+        else:
+            def joinpath(self, child: str) -> abc.Traversable: ...
+
+        if sys.version_info < (3, 12):
+            __truediv__ = joinpath
+
+        def open(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+        @property
+        def name(self) -> str: ...
+
+    class NamespaceReader(abc.TraversableResources):
+        path: MultiplexedPath
+        def __init__(self, namespace_path) -> None: ...
+        def resource_path(self, resource: str) -> str: ...
+        def files(self) -> MultiplexedPath: ...

jaclang/vendor/mypy/typeshed/stdlib/importlib/resources/__init__.pyi

@@ -0,0 +1,46 @@
+import os
+import sys
+from collections.abc import Iterator
+from contextlib import AbstractContextManager
+from pathlib import Path
+from types import ModuleType
+from typing import Any, BinaryIO, TextIO
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 9):
+    from importlib.abc import Traversable
+
+__all__ = ["Package", "Resource", "contents", "is_resource", "open_binary", "open_text", "path", "read_binary", "read_text"]
+
+if sys.version_info >= (3, 9):
+    __all__ += ["as_file", "files"]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["ResourceReader"]
+
+Package: TypeAlias = str | ModuleType
+
+if sys.version_info >= (3, 11):
+    Resource: TypeAlias = str
+else:
+    Resource: TypeAlias = str | os.PathLike[Any]
+
+def open_binary(package: Package, resource: Resource) -> BinaryIO: ...
+def open_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> TextIO: ...
+def read_binary(package: Package, resource: Resource) -> bytes: ...
+def read_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> str: ...
+def path(package: Package, resource: Resource) -> AbstractContextManager[Path]: ...
+def is_resource(package: Package, name: str) -> bool: ...
+def contents(package: Package) -> Iterator[str]: ...
+
+if sys.version_info >= (3, 9):
+    def as_file(path: Traversable) -> AbstractContextManager[Path]: ...
+
+if sys.version_info >= (3, 12):
+    def files(anchor: Package | None = ...) -> Traversable: ...
+
+elif sys.version_info >= (3, 9):
+    def files(package: Package) -> Traversable: ...
+
+if sys.version_info >= (3, 10):
+    from importlib.abc import ResourceReader as ResourceReader

jaclang/vendor/mypy/typeshed/stdlib/importlib/resources/abc.pyi

@@ -0,0 +1,12 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    # These are all actually defined in this file on 3.11+,
+    # and re-exported from importlib.abc,
+    # but it's much less code duplication for typeshed if we pretend that they're still defined
+    # in importlib.abc on 3.11+, and re-exported from this file
+    from importlib.abc import (
+        ResourceReader as ResourceReader,
+        Traversable as Traversable,
+        TraversableResources as TraversableResources,
+    )

jaclang/vendor/mypy/typeshed/stdlib/importlib/resources/readers.pyi

@@ -0,0 +1,14 @@
+# On py311+, things are actually defined here
+# and re-exported from importlib.readers,
+# but doing it this way leads to less code duplication for us
+
+import sys
+from collections.abc import Iterable, Iterator
+from typing import TypeVar
+
+if sys.version_info >= (3, 11):
+    from importlib.readers import *
+
+    _T = TypeVar("_T")
+
+    def remove_duplicates(items: Iterable[_T]) -> Iterator[_T]: ...

jaclang/vendor/mypy/typeshed/stdlib/importlib/resources/simple.pyi

@@ -0,0 +1,56 @@
+import abc
+import sys
+from collections.abc import Iterator
+from io import TextIOWrapper
+from typing import IO, Any, BinaryIO, Literal, NoReturn, overload
+from typing_extensions import Never
+
+if sys.version_info >= (3, 11):
+    from .abc import Traversable, TraversableResources
+
+    class SimpleReader(abc.ABC):
+        @property
+        @abc.abstractmethod
+        def package(self) -> str: ...
+        @abc.abstractmethod
+        def children(self) -> list[SimpleReader]: ...
+        @abc.abstractmethod
+        def resources(self) -> list[str]: ...
+        @abc.abstractmethod
+        def open_binary(self, resource: str) -> BinaryIO: ...
+        @property
+        def name(self) -> str: ...
+
+    class ResourceHandle(Traversable, metaclass=abc.ABCMeta):
+        parent: ResourceContainer
+        def __init__(self, parent: ResourceContainer, name: str) -> None: ...
+        def is_file(self) -> Literal[True]: ...
+        def is_dir(self) -> Literal[False]: ...
+        @overload
+        def open(
+            self,
+            mode: Literal["r"] = "r",
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+            line_buffering: bool = False,
+            write_through: bool = False,
+        ) -> TextIOWrapper: ...
+        @overload
+        def open(self, mode: Literal["rb"]) -> BinaryIO: ...
+        @overload
+        def open(self, mode: str) -> IO[Any]: ...
+        def joinpath(self, name: Never) -> NoReturn: ...  # type: ignore[override]
+
+    class ResourceContainer(Traversable, metaclass=abc.ABCMeta):
+        reader: SimpleReader
+        def __init__(self, reader: SimpleReader) -> None: ...
+        def is_dir(self) -> Literal[True]: ...
+        def is_file(self) -> Literal[False]: ...
+        def iterdir(self) -> Iterator[ResourceHandle | ResourceContainer]: ...
+        def open(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+        if sys.version_info < (3, 12):
+            def joinpath(self, *descendants: str) -> Traversable: ...
+
+    class TraversableReader(TraversableResources, SimpleReader, metaclass=abc.ABCMeta):
+        def files(self) -> ResourceContainer: ...

jaclang/vendor/mypy/typeshed/stdlib/importlib/simple.pyi

@@ -0,0 +1,11 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from .resources.simple import (
+        ResourceContainer as ResourceContainer,
+        ResourceHandle as ResourceHandle,
+        SimpleReader as SimpleReader,
+        TraversableReader as TraversableReader,
+    )
+
+    __all__ = ["SimpleReader", "ResourceHandle", "ResourceContainer", "TraversableReader"]

jaclang/vendor/mypy/typeshed/stdlib/importlib/util.pyi

@@ -0,0 +1,43 @@
+import importlib.abc
+import importlib.machinery
+import sys
+import types
+from _typeshed import ReadableBuffer, StrOrBytesPath
+from collections.abc import Callable
+from typing import Any
+from typing_extensions import ParamSpec
+
+_P = ParamSpec("_P")
+
+if sys.version_info < (3, 12):
+    def module_for_loader(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
+    def set_loader(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
+    def set_package(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
+
+def resolve_name(name: str, package: str | None) -> str: ...
+
+MAGIC_NUMBER: bytes
+
+def cache_from_source(path: str, debug_override: bool | None = None, *, optimization: Any | None = None) -> str: ...
+def source_from_cache(path: str) -> str: ...
+def decode_source(source_bytes: ReadableBuffer) -> str: ...
+def find_spec(name: str, package: str | None = None) -> importlib.machinery.ModuleSpec | None: ...
+def spec_from_loader(
+    name: str, loader: importlib.abc.Loader | None, *, origin: str | None = None, is_package: bool | None = None
+) -> importlib.machinery.ModuleSpec | None: ...
+def spec_from_file_location(
+    name: str,
+    location: StrOrBytesPath | None = None,
+    *,
+    loader: importlib.abc.Loader | None = None,
+    submodule_search_locations: list[str] | None = ...,
+) -> importlib.machinery.ModuleSpec | None: ...
+def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ...
+
+class LazyLoader(importlib.abc.Loader):
+    def __init__(self, loader: importlib.abc.Loader) -> None: ...
+    @classmethod
+    def factory(cls, loader: importlib.abc.Loader) -> Callable[..., LazyLoader]: ...
+    def exec_module(self, module: types.ModuleType) -> None: ...
+
+def source_hash(source_bytes: ReadableBuffer) -> bytes: ...