layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/zipfile/__init__.pyi

@@ -0,0 +1,411 @@
+import io
+import sys
+from _typeshed import SizedBuffer, StrOrBytesPath, StrPath
+from collections.abc import Callable, Iterable, Iterator
+from io import TextIOWrapper
+from os import PathLike
+from types import TracebackType
+from typing import IO, Final, Literal, Protocol, TypeAlias, overload, type_check_only
+from typing_extensions import Self
+
+__all__ = [
+    "BadZipFile",
+    "BadZipfile",
+    "Path",
+    "error",
+    "ZIP_STORED",
+    "ZIP_DEFLATED",
+    "ZIP_BZIP2",
+    "ZIP_LZMA",
+    "is_zipfile",
+    "ZipInfo",
+    "ZipFile",
+    "PyZipFile",
+    "LargeZipFile",
+]
+
+if sys.version_info >= (3, 14):
+    __all__ += ["ZIP_ZSTANDARD"]
+
+# TODO: use TypeAlias for these two when mypy bugs are fixed
+# https://github.com/python/mypy/issues/16581
+_DateTuple = tuple[int, int, int, int, int, int]  # noqa: Y026
+_ZipFileMode = Literal["r", "w", "x", "a"]  # noqa: Y026
+
+_ReadWriteMode: TypeAlias = Literal["r", "w"]
+
+class BadZipFile(Exception): ...
+
+BadZipfile = BadZipFile
+error = BadZipfile
+
+class LargeZipFile(Exception): ...
+
+@type_check_only
+class _ZipStream(Protocol):
+    def read(self, n: int, /) -> bytes: ...
+    # The following methods are optional:
+    # def seekable(self) -> bool: ...
+    # def tell(self) -> int: ...
+    # def seek(self, n: int, /) -> object: ...
+
+# Stream shape as required by _EndRecData() and _EndRecData64().
+@type_check_only
+class _SupportsReadSeekTell(Protocol):
+    def read(self, n: int = ..., /) -> bytes: ...
+    def seek(self, cookie: int, whence: int, /) -> object: ...
+    def tell(self) -> int: ...
+
+@type_check_only
+class _ClosableZipStream(_ZipStream, Protocol):
+    def close(self) -> object: ...
+
+class ZipExtFile(io.BufferedIOBase):
+    MAX_N: int
+    MIN_READ_SIZE: int
+    MAX_SEEK_READ: int
+    newlines: list[bytes] | None
+    mode: _ReadWriteMode
+    name: str
+
+    @overload
+    def __init__(
+        self, fileobj: _ClosableZipStream, mode: _ReadWriteMode, zipinfo: ZipInfo, pwd: bytes | None, close_fileobj: Literal[True]
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        fileobj: _ClosableZipStream,
+        mode: _ReadWriteMode,
+        zipinfo: ZipInfo,
+        pwd: bytes | None = None,
+        *,
+        close_fileobj: Literal[True],
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        fileobj: _ZipStream,
+        mode: _ReadWriteMode,
+        zipinfo: ZipInfo,
+        pwd: bytes | None = None,
+        close_fileobj: Literal[False] = False,
+    ) -> None: ...
+
+    def read(self, n: int | None = -1) -> bytes: ...
+    def readline(self, limit: int = -1) -> bytes: ...  # type: ignore[override]
+    def peek(self, n: int = 1) -> bytes: ...
+    def read1(self, n: int | None) -> bytes: ...  # type: ignore[override]
+    def seek(self, offset: int, whence: int = 0) -> int: ...
+
+@type_check_only
+class _Writer(Protocol):
+    def write(self, s: str, /) -> object: ...
+
+@type_check_only
+class _ZipReadable(Protocol):
+    def seek(self, offset: int, whence: int = 0, /) -> int: ...
+    def read(self, n: int = -1, /) -> bytes: ...
+
+@type_check_only
+class _ZipTellable(Protocol):
+    def tell(self) -> int: ...
+
+@type_check_only
+class _ZipReadableTellable(_ZipReadable, _ZipTellable, Protocol): ...
+
+@type_check_only
+class _ZipWritable(Protocol):
+    def flush(self) -> None: ...
+    def close(self) -> None: ...
+    def write(self, b: bytes, /) -> int: ...
+
+class ZipFile:
+    filename: str | None
+    debug: int
+    comment: bytes
+    filelist: list[ZipInfo]
+    fp: IO[bytes] | None
+    NameToInfo: dict[str, ZipInfo]
+    start_dir: int  # undocumented
+    compression: int  # undocumented
+    compresslevel: int | None  # undocumented
+    mode: _ZipFileMode  # undocumented
+    pwd: bytes | None  # undocumented
+    # metadata_encoding is new in 3.11
+    if sys.version_info >= (3, 11):
+        @overload
+        def __init__(
+            self,
+            file: StrPath | IO[bytes],
+            mode: _ZipFileMode = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+            metadata_encoding: str | None = None,
+        ) -> None: ...
+        # metadata_encoding is only allowed for read mode
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipReadable,
+            mode: Literal["r"] = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+            metadata_encoding: str | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipWritable,
+            mode: Literal["w", "x"],
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+            metadata_encoding: None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipReadableTellable,
+            mode: Literal["a"],
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+            metadata_encoding: None = None,
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self,
+            file: StrPath | IO[bytes],
+            mode: _ZipFileMode = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipReadable,
+            mode: Literal["r"] = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipWritable,
+            mode: Literal["w", "x"],
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipReadableTellable,
+            mode: Literal["a"],
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+        ) -> None: ...
+
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+    ) -> None: ...
+    def close(self) -> None: ...
+    def getinfo(self, name: str) -> ZipInfo: ...
+    def infolist(self) -> list[ZipInfo]: ...
+    def namelist(self) -> list[str]: ...
+    def open(
+        self, name: str | ZipInfo, mode: _ReadWriteMode = "r", pwd: bytes | None = None, *, force_zip64: bool = False
+    ) -> IO[bytes]: ...
+    def extract(self, member: str | ZipInfo, path: StrPath | None = None, pwd: bytes | None = None) -> str: ...
+    def extractall(
+        self, path: StrPath | None = None, members: Iterable[str | ZipInfo] | None = None, pwd: bytes | None = None
+    ) -> None: ...
+    def printdir(self, file: _Writer | None = None) -> None: ...
+    def setpassword(self, pwd: bytes) -> None: ...
+    def read(self, name: str | ZipInfo, pwd: bytes | None = None) -> bytes: ...
+    def testzip(self) -> str | None: ...
+    def write(
+        self,
+        filename: StrPath,
+        arcname: StrPath | None = None,
+        compress_type: int | None = None,
+        compresslevel: int | None = None,
+    ) -> None: ...
+    def writestr(
+        self,
+        zinfo_or_arcname: str | ZipInfo,
+        data: SizedBuffer | str,
+        compress_type: int | None = None,
+        compresslevel: int | None = None,
+    ) -> None: ...
+    if sys.version_info >= (3, 11):
+        def mkdir(self, zinfo_or_directory_name: str | ZipInfo, mode: int = 0o777) -> None: ...
+
+    def __del__(self) -> None: ...
+
+class PyZipFile(ZipFile):
+    def __init__(
+        self, file: str | IO[bytes], mode: _ZipFileMode = "r", compression: int = 0, allowZip64: bool = True, optimize: int = -1
+    ) -> None: ...
+    def writepy(self, pathname: str, basename: str = "", filterfunc: Callable[[str], bool] | None = None) -> None: ...
+
+class ZipInfo:
+    __slots__ = (
+        "orig_filename",
+        "filename",
+        "date_time",
+        "compress_type",
+        "compress_level",
+        "comment",
+        "extra",
+        "create_system",
+        "create_version",
+        "extract_version",
+        "reserved",
+        "flag_bits",
+        "volume",
+        "internal_attr",
+        "external_attr",
+        "header_offset",
+        "CRC",
+        "compress_size",
+        "file_size",
+        "_raw_time",
+        "_end_offset",
+    )
+    filename: str
+    date_time: _DateTuple
+    compress_type: int
+    comment: bytes
+    extra: bytes
+    create_system: int
+    create_version: int
+    extract_version: int
+    reserved: int
+    flag_bits: int
+    volume: int
+    internal_attr: int
+    external_attr: int
+    header_offset: int
+    CRC: int
+    compress_size: int
+    file_size: int
+    orig_filename: str  # undocumented
+    if sys.version_info >= (3, 13):
+        compress_level: int | None
+
+    def __init__(self, filename: str = "NoName", date_time: _DateTuple = (1980, 1, 1, 0, 0, 0)) -> None: ...
+    @classmethod
+    def from_file(cls, filename: StrPath, arcname: StrPath | None = None, *, strict_timestamps: bool = True) -> Self: ...
+    def is_dir(self) -> bool: ...
+    def FileHeader(self, zip64: bool | None = None) -> bytes: ...
+    if sys.version_info >= (3, 14):
+        def _for_archive(self, archive: ZipFile) -> Self: ...
+
+if sys.version_info >= (3, 12):
+    from zipfile._path import CompleteDirs as CompleteDirs, Path as Path
+
+else:
+    class CompleteDirs(ZipFile):
+        def resolve_dir(self, name: str) -> str: ...
+
+        @overload
+        @classmethod
+        def make(cls, source: ZipFile) -> CompleteDirs: ...
+        @overload
+        @classmethod
+        def make(cls, source: StrPath | IO[bytes]) -> Self: ...
+
+    class Path:
+        root: CompleteDirs
+        at: str
+        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
+        @property
+        def name(self) -> str: ...
+        @property
+        def parent(self) -> PathLike[str]: ...  # undocumented
+        @property
+        def filename(self) -> PathLike[str]: ...  # undocumented
+        if sys.version_info >= (3, 11):
+            @property
+            def suffix(self) -> str: ...
+            @property
+            def suffixes(self) -> list[str]: ...
+            @property
+            def stem(self) -> str: ...
+
+        @overload
+        def open(
+            self,
+            mode: Literal["r", "w"] = "r",
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+            line_buffering: bool = False,
+            write_through: bool = False,
+            *,
+            pwd: bytes | None = None,
+        ) -> TextIOWrapper: ...
+        @overload
+        def open(self, mode: Literal["rb", "wb"], *, pwd: bytes | None = None) -> IO[bytes]: ...
+
+        def iterdir(self) -> Iterator[Self]: ...
+        def is_dir(self) -> bool: ...
+        def is_file(self) -> bool: ...
+        def exists(self) -> bool: ...
+        def read_text(
+            self,
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+            line_buffering: bool = False,
+            write_through: bool = False,
+        ) -> str: ...
+        def read_bytes(self) -> bytes: ...
+        def joinpath(self, *other: StrPath) -> Path: ...
+        def __truediv__(self, add: StrPath) -> Path: ...
+
+def is_zipfile(filename: StrOrBytesPath | _SupportsReadSeekTell) -> bool: ...
+
+ZIP64_LIMIT: Final[int]
+ZIP_FILECOUNT_LIMIT: Final[int]
+ZIP_MAX_COMMENT: Final[int]
+
+ZIP_STORED: Final = 0
+ZIP_DEFLATED: Final = 8
+ZIP_BZIP2: Final = 12
+ZIP_LZMA: Final = 14
+if sys.version_info >= (3, 14):
+    ZIP_ZSTANDARD: Final = 93
+
+DEFAULT_VERSION: Final[int]
+ZIP64_VERSION: Final[int]
+BZIP2_VERSION: Final[int]
+LZMA_VERSION: Final[int]
+if sys.version_info >= (3, 14):
+    ZSTANDARD_VERSION: Final[int]
+MAX_EXTRACT_VERSION: Final[int]

package/analyzers/project-map-python/typeshed/stdlib/zipfile/_path/__init__.pyi

@@ -0,0 +1,87 @@
+import sys
+from _typeshed import StrPath
+from collections.abc import Iterator, Sequence
+from io import TextIOWrapper
+from os import PathLike
+from typing import IO, Literal, TypeVar, overload
+from typing_extensions import Self
+from zipfile import ZipFile
+
+_ZF = TypeVar("_ZF", bound=ZipFile)
+
+if sys.version_info >= (3, 12):
+    __all__ = ["Path"]
+
+    class InitializedState:
+        def __init__(self, *args: object, **kwargs: object) -> None: ...
+        def __getstate__(self) -> tuple[list[object], dict[object, object]]: ...
+        def __setstate__(self, state: Sequence[tuple[list[object], dict[object, object]]]) -> None: ...
+
+    class CompleteDirs(InitializedState, ZipFile):
+        def resolve_dir(self, name: str) -> str: ...
+
+        @overload
+        @classmethod
+        def make(cls, source: ZipFile) -> CompleteDirs: ...
+        @overload
+        @classmethod
+        def make(cls, source: StrPath | IO[bytes]) -> Self: ...
+
+        if sys.version_info >= (3, 13):
+            @classmethod
+            def inject(cls, zf: _ZF) -> _ZF: ...
+
+    class Path:
+        root: CompleteDirs
+        at: str
+        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
+        @property
+        def name(self) -> str: ...
+        @property
+        def parent(self) -> PathLike[str]: ...  # undocumented
+        @property
+        def filename(self) -> PathLike[str]: ...  # undocumented
+        @property
+        def suffix(self) -> str: ...
+        @property
+        def suffixes(self) -> list[str]: ...
+        @property
+        def stem(self) -> str: ...
+
+        @overload
+        def open(
+            self,
+            mode: Literal["r", "w"] = "r",
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+            line_buffering: bool = False,
+            write_through: bool = False,
+            *,
+            pwd: bytes | None = None,
+        ) -> TextIOWrapper: ...
+        @overload
+        def open(self, mode: Literal["rb", "wb"], *, pwd: bytes | None = None) -> IO[bytes]: ...
+
+        def iterdir(self) -> Iterator[Self]: ...
+        def is_dir(self) -> bool: ...
+        def is_file(self) -> bool: ...
+        def exists(self) -> bool: ...
+        def read_text(
+            self,
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+            line_buffering: bool = False,
+            write_through: bool = False,
+        ) -> str: ...
+        def read_bytes(self) -> bytes: ...
+        def joinpath(self, *other: StrPath) -> Path: ...
+        def glob(self, pattern: str) -> Iterator[Self]: ...
+        def rglob(self, pattern: str) -> Iterator[Self]: ...
+        def is_symlink(self) -> Literal[False]: ...
+        def relative_to(self, other: Path, *extra: StrPath) -> str: ...
+        def match(self, path_pattern: str) -> bool: ...
+        def __eq__(self, other: object) -> bool: ...
+        def __hash__(self) -> int: ...
+        def __truediv__(self, add: StrPath) -> Path: ...

package/analyzers/project-map-python/typeshed/stdlib/zipfile/_path/glob.pyi

@@ -0,0 +1,26 @@
+import sys
+from collections.abc import Iterator
+from re import Match
+
+if sys.version_info >= (3, 13):
+    class Translator:
+        if sys.platform == "win32":
+            def __init__(self, seps: str = "\\/") -> None: ...
+        else:
+            def __init__(self, seps: str = "/") -> None: ...
+
+        def translate(self, pattern: str) -> str: ...
+        def extend(self, pattern: str) -> str: ...
+        def match_dirs(self, pattern: str) -> str: ...
+        def translate_core(self, pattern: str) -> str: ...
+        def replace(self, match: Match[str]) -> str: ...
+        def restrict_rglob(self, pattern: str) -> None: ...
+        def star_not_empty(self, pattern: str) -> str: ...
+
+else:
+    def translate(pattern: str) -> str: ...
+    def match_dirs(pattern: str) -> str: ...
+    def translate_core(pattern: str) -> str: ...
+    def replace(match: Match[str]) -> str: ...
+
+def separate(pattern: str) -> Iterator[Match[str]]: ...

package/analyzers/project-map-python/typeshed/stdlib/zipimport.pyi

@@ -0,0 +1,44 @@
+import sys
+from _frozen_importlib_external import _LoaderBasics
+from _typeshed import StrOrBytesPath
+from importlib.machinery import ModuleSpec
+from importlib.readers import ZipReader
+from types import CodeType, ModuleType
+from typing_extensions import deprecated
+
+__all__ = ["ZipImportError", "zipimporter"]
+
+class ZipImportError(ImportError): ...
+
+class zipimporter(_LoaderBasics):
+    archive: str
+    prefix: str
+    if sys.version_info >= (3, 11):
+        def __init__(self, path: str) -> None: ...
+    else:
+        def __init__(self, path: StrOrBytesPath) -> None: ...
+
+    if sys.version_info < (3, 12):
+        @deprecated("Deprecated since Python 3.10; removed in Python 3.12. Use `find_spec()` instead.")
+        def find_loader(self, fullname: str, path: str | None = None) -> tuple[zipimporter | None, list[str]]: ...
+        @deprecated("Deprecated since Python 3.10; removed in Python 3.12. Use `find_spec()` instead.")
+        def find_module(self, fullname: str, path: str | None = None) -> zipimporter | None: ...
+
+    def get_code(self, fullname: str) -> CodeType: ...
+    def get_data(self, pathname: str) -> bytes: ...
+    def get_filename(self, fullname: str) -> str: ...
+    if sys.version_info >= (3, 14):
+        def get_resource_reader(self, fullname: str) -> ZipReader: ...  # undocumented
+    else:
+        def get_resource_reader(self, fullname: str) -> ZipReader | None: ...  # undocumented
+
+    def get_source(self, fullname: str) -> str | None: ...
+    def is_package(self, fullname: str) -> bool: ...
+    if sys.version_info < (3, 15):
+        @deprecated("Deprecated since Python 3.10; removed in Python 3.15. Use `exec_module()` instead.")
+        def load_module(self, fullname: str) -> ModuleType: ...
+
+    def exec_module(self, module: ModuleType) -> None: ...
+    def create_module(self, spec: ModuleSpec) -> None: ...
+    def find_spec(self, fullname: str, target: ModuleType | None = None) -> ModuleSpec | None: ...
+    def invalidate_caches(self) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/zlib.pyi

@@ -0,0 +1,81 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import Any, Final, final, type_check_only
+from typing_extensions import Self
+
+DEFLATED: Final = 8
+DEF_MEM_LEVEL: Final[int]
+DEF_BUF_SIZE: Final = 16384
+MAX_WBITS: Final[int]
+ZLIB_VERSION: Final[str]
+ZLIB_RUNTIME_VERSION: Final[str]
+Z_NO_COMPRESSION: Final = 0
+Z_PARTIAL_FLUSH: Final = 1
+Z_BEST_COMPRESSION: Final = 9
+Z_BEST_SPEED: Final = 1
+Z_BLOCK: Final = 5
+Z_DEFAULT_COMPRESSION: Final = -1
+Z_DEFAULT_STRATEGY: Final = 0
+Z_FILTERED: Final = 1
+Z_FINISH: Final = 4
+Z_FIXED: Final = 4
+Z_FULL_FLUSH: Final = 3
+Z_HUFFMAN_ONLY: Final = 2
+Z_NO_FLUSH: Final = 0
+Z_RLE: Final = 3
+Z_SYNC_FLUSH: Final = 2
+Z_TREES: Final = 6
+
+if sys.version_info >= (3, 14):
+    # Available when zlib was built with zlib-ng
+    ZLIBNG_VERSION: Final[str]
+
+class error(Exception): ...
+
+# This class is not exposed at runtime. It calls itself zlib.Compress.
+@final
+@type_check_only
+class _Compress:
+    def __copy__(self) -> Self: ...
+    def __deepcopy__(self, memo: Any, /) -> Self: ...
+    def compress(self, data: ReadableBuffer, /) -> bytes: ...
+    def flush(self, mode: int = 4, /) -> bytes: ...
+    def copy(self) -> _Compress: ...
+
+# This class is not exposed at runtime. It calls itself zlib.Decompress.
+@final
+@type_check_only
+class _Decompress:
+    @property
+    def unused_data(self) -> bytes: ...
+    @property
+    def unconsumed_tail(self) -> bytes: ...
+    @property
+    def eof(self) -> bool: ...
+    def __copy__(self) -> Self: ...
+    def __deepcopy__(self, memo: Any, /) -> Self: ...
+    def decompress(self, data: ReadableBuffer, /, max_length: int = 0) -> bytes: ...
+    def flush(self, length: int = 16384, /) -> bytes: ...
+    def copy(self) -> _Decompress: ...
+
+def adler32(data: ReadableBuffer, value: int = 1, /) -> int: ...
+
+if sys.version_info >= (3, 15):
+    def adler32_combine(adler1: int, adler2: int, len2: int, /) -> int: ...
+
+if sys.version_info >= (3, 11):
+    def compress(data: ReadableBuffer, /, level: int = -1, wbits: int = 15) -> bytes: ...
+
+else:
+    def compress(data: ReadableBuffer, /, level: int = -1) -> bytes: ...
+
+def compressobj(
+    level: int = -1, method: int = 8, wbits: int = 15, memLevel: int = 8, strategy: int = 0, zdict: ReadableBuffer | None = None
+) -> _Compress: ...
+def crc32(data: ReadableBuffer, value: int = 0, /) -> int: ...
+
+if sys.version_info >= (3, 15):
+    def crc32_combine(crc1: int, crc2: int, len2: int, /) -> int: ...
+
+def decompress(data: ReadableBuffer, /, wbits: int = 15, bufsize: int = 16384) -> bytes: ...
+def decompressobj(wbits: int = 15, zdict: ReadableBuffer = b"") -> _Decompress: ...

package/analyzers/project-map-python/typeshed/stdlib/zoneinfo/__init__.pyi

@@ -0,0 +1,36 @@
+import sys
+from collections.abc import Iterable
+from datetime import datetime, timedelta, tzinfo
+from typing_extensions import Self, disjoint_base
+from zoneinfo._common import ZoneInfoNotFoundError as ZoneInfoNotFoundError, _IOBytes
+from zoneinfo._tzpath import (
+    TZPATH as TZPATH,
+    InvalidTZPathWarning as InvalidTZPathWarning,
+    available_timezones as available_timezones,
+    reset_tzpath as reset_tzpath,
+)
+
+__all__ = ["ZoneInfo", "reset_tzpath", "available_timezones", "TZPATH", "ZoneInfoNotFoundError", "InvalidTZPathWarning"]
+
+@disjoint_base
+class ZoneInfo(tzinfo):
+    @property
+    def key(self) -> str: ...
+    def __new__(cls, key: str) -> Self: ...
+    @classmethod
+    def no_cache(cls, key: str) -> Self: ...
+
+    if sys.version_info >= (3, 12):
+        @classmethod
+        def from_file(cls, file_obj: _IOBytes, /, key: str | None = None) -> Self: ...
+    else:
+        @classmethod
+        def from_file(cls, fobj: _IOBytes, /, key: str | None = None) -> Self: ...
+
+    @classmethod
+    def clear_cache(cls, *, only_keys: Iterable[str] | None = None) -> None: ...
+    def tzname(self, dt: datetime | None, /) -> str | None: ...
+    def utcoffset(self, dt: datetime | None, /) -> timedelta | None: ...
+    def dst(self, dt: datetime | None, /) -> timedelta | None: ...
+
+def __dir__() -> list[str]: ...

package/analyzers/project-map-python/typeshed/stdlib/zoneinfo/_common.pyi

@@ -0,0 +1,14 @@
+import io
+from typing import Any, Protocol, type_check_only
+
+@type_check_only
+class _IOBytes(Protocol):
+    def read(self, size: int, /) -> bytes: ...
+    def seek(self, size: int, whence: int = ..., /) -> Any: ...
+
+def load_tzdata(key: str) -> io.BufferedReader: ...
+def load_data(
+    fobj: _IOBytes,
+) -> tuple[tuple[int, ...], tuple[int, ...], tuple[int, ...], tuple[int, ...], tuple[str, ...], bytes | None]: ...
+
+class ZoneInfoNotFoundError(KeyError): ...