_analysis.pyi

# File generated with docstub

import builtins
import importlib
import json
import logging
import re
from collections.abc import Iterable
from dataclasses import asdict, dataclass
from functools import cache
from pathlib import Path
from typing import Any, ClassVar

import libcst as cst
import libcst.matchers as cstm

from ._report import Stats
from ._utils import accumulate_qualname, module_name_from_path, pyfile_checksum

logger: logging.Logger

def _shared_leading_qualname(*qualnames: tuple[str]) -> str: ...
@dataclass(slots=True, frozen=True)
class PyImport:

    import_: str | None = ...
    from_: str | None = ...
    as_: str | None = ...
    implicit: str | None = ...

    @classmethod
    def typeshed_Incomplete(cls) -> PyImport: ...
    def format_import(self, relative_to: str | None = ...) -> str: ...
    @property
    def target(self) -> str: ...
    @property
    def has_import(self) -> None: ...
    def __post_init__(self) -> None: ...
    def __repr__(self) -> str: ...
    def __str__(self) -> str: ...

def _is_type(value: Any) -> bool: ...
def _builtin_types() -> dict[str, PyImport]: ...
def _runtime_types_in_module(module_name: str) -> dict[str, PyImport]: ...
def common_known_types() -> dict[str, PyImport]: ...

class TypeCollector(cst.CSTVisitor):
    class ImportSerializer:

        suffix: ClassVar[str]
        encoding: ClassVar[str]

        def hash_args(self, path: Path) -> str: ...
        def serialize(
            self, data: tuple[dict[str, PyImport], dict[str, PyImport]]
        ) -> bytes: ...
        def deserialize(
            self, raw: bytes
        ) -> tuple[dict[str, PyImport], dict[str, PyImport]]: ...

    @classmethod
    def collect(cls, file: Path) -> tuple[dict[str, PyImport], dict[str, PyImport]]: ...
    def __init__(self, *, module_name: str) -> None: ...
    def visit_ClassDef(self, node: cst.ClassDef) -> bool: ...
    def leave_ClassDef(self, original_node: cst.ClassDef) -> None: ...
    def visit_FunctionDef(self, node: cst.FunctionDef) -> bool: ...
    def visit_TypeAlias(self, node: cst.TypeAlias) -> bool: ...
    def visit_AnnAssign(self, node: cst.AnnAssign) -> bool: ...
    def visit_ImportFrom(self, node: cst.ImportFrom) -> bool: ...
    def visit_Import(self, node: cst.Import) -> bool: ...
    def _collect_type_annotation(self, stack: Iterable[str]) -> None: ...

class TypeMatcher:
    types: dict[str, PyImport]
    type_prefixes: dict[str, PyImport]
    type_nicknames: dict[str, str]
    successful_queries: int
    unknown_qualnames: list
    current_file: Path | None

    def __init__(
        self,
        *,
        types: dict[str, PyImport] | None = ...,
        type_prefixes: dict[str, PyImport] | None = ...,
        type_nicknames: dict[str, str] | None = ...,
        stats: Stats | None = ...,
    ) -> None: ...
    def _resolve_nickname(self, name: str) -> str: ...
    def match(self, search: str) -> tuple[str | None, PyImport | None]: ...