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

jaclang/vendor/mypy/typeshed/stdlib/dataclasses.pyi

@@ -0,0 +1,323 @@
+import enum
+import sys
+import types
+from _typeshed import DataclassInstance
+from builtins import (
+    type as Type,
+)  # alias to avoid name clashes with fields named "type"
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any, Generic, Literal, Protocol, TypeVar, overload
+from typing_extensions import TypeAlias, TypeGuard
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+
+__all__ = [
+    "dataclass",
+    "field",
+    "Field",
+    "FrozenInstanceError",
+    "InitVar",
+    "MISSING",
+    "fields",
+    "asdict",
+    "astuple",
+    "make_dataclass",
+    "replace",
+    "is_dataclass",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["KW_ONLY"]
+
+_DataclassT = TypeVar("_DataclassT", bound=DataclassInstance)
+
+# define _MISSING_TYPE as an enum within the type stubs,
+# even though that is not really its type at runtime
+# this allows us to use Literal[_MISSING_TYPE.MISSING]
+# for background, see:
+#   https://github.com/python/typeshed/pull/5900#issuecomment-895513797
+class _MISSING_TYPE(enum.Enum):
+    MISSING = enum.auto()
+
+MISSING = _MISSING_TYPE.MISSING
+
+if sys.version_info >= (3, 10):
+    class KW_ONLY: ...
+
+@overload
+def asdict(obj: DataclassInstance) -> dict[str, Any]: ...
+@overload
+def asdict(
+    obj: DataclassInstance, *, dict_factory: Callable[[list[tuple[str, Any]]], _T]
+) -> _T: ...
+@overload
+def astuple(obj: DataclassInstance) -> tuple[Any, ...]: ...
+@overload
+def astuple(
+    obj: DataclassInstance, *, tuple_factory: Callable[[list[Any]], _T]
+) -> _T: ...
+@overload
+def dataclass(__cls: None) -> Callable[[type[_T]], type[_T]]: ...
+@overload
+def dataclass(__cls: type[_T]) -> type[_T]: ...
+
+if sys.version_info >= (3, 11):
+    @overload
+    def dataclass(
+        *,
+        init: bool = True,
+        repr: bool = True,
+        eq: bool = True,
+        order: bool = False,
+        unsafe_hash: bool = False,
+        frozen: bool = False,
+        match_args: bool = True,
+        kw_only: bool = False,
+        slots: bool = False,
+        weakref_slot: bool = False,
+    ) -> Callable[[type[_T]], type[_T]]: ...
+
+elif sys.version_info >= (3, 10):
+    @overload
+    def dataclass(
+        *,
+        init: bool = True,
+        repr: bool = True,
+        eq: bool = True,
+        order: bool = False,
+        unsafe_hash: bool = False,
+        frozen: bool = False,
+        match_args: bool = True,
+        kw_only: bool = False,
+        slots: bool = False,
+    ) -> Callable[[type[_T]], type[_T]]: ...
+
+else:
+    @overload
+    def dataclass(
+        *,
+        init: bool = True,
+        repr: bool = True,
+        eq: bool = True,
+        order: bool = False,
+        unsafe_hash: bool = False,
+        frozen: bool = False,
+    ) -> Callable[[type[_T]], type[_T]]: ...
+
+# See https://github.com/python/mypy/issues/10750
+class _DefaultFactory(Protocol[_T_co]):
+    def __call__(self) -> _T_co: ...
+
+class Field(Generic[_T]):
+    name: str
+    type: Type[_T]
+    default: _T | Literal[_MISSING_TYPE.MISSING]
+    default_factory: _DefaultFactory[_T] | Literal[_MISSING_TYPE.MISSING]
+    repr: bool
+    hash: bool | None
+    init: bool
+    compare: bool
+    metadata: types.MappingProxyType[Any, Any]
+    if sys.version_info >= (3, 10):
+        kw_only: bool | Literal[_MISSING_TYPE.MISSING]
+        def __init__(
+            self,
+            default: _T,
+            default_factory: Callable[[], _T],
+            init: bool,
+            repr: bool,
+            hash: bool | None,
+            compare: bool,
+            metadata: Mapping[Any, Any],
+            kw_only: bool,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            default: _T,
+            default_factory: Callable[[], _T],
+            init: bool,
+            repr: bool,
+            hash: bool | None,
+            compare: bool,
+            metadata: Mapping[Any, Any],
+        ) -> None: ...
+
+    def __set_name__(self, owner: Type[Any], name: str) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+# NOTE: Actual return type is 'Field[_T]', but we want to help type checkers
+# to understand the magic that happens at runtime.
+if sys.version_info >= (3, 10):
+    @overload  # `default` and `default_factory` are optional and mutually exclusive.
+    def field(
+        *,
+        default: _T,
+        init: bool = True,
+        repr: bool = True,
+        hash: bool | None = None,
+        compare: bool = True,
+        metadata: Mapping[Any, Any] | None = None,
+        kw_only: bool = ...,
+    ) -> _T: ...
+    @overload
+    def field(
+        *,
+        default_factory: Callable[[], _T],
+        init: bool = True,
+        repr: bool = True,
+        hash: bool | None = None,
+        compare: bool = True,
+        metadata: Mapping[Any, Any] | None = None,
+        kw_only: bool = ...,
+    ) -> _T: ...
+    @overload
+    def field(
+        *,
+        init: bool = True,
+        repr: bool = True,
+        hash: bool | None = None,
+        compare: bool = True,
+        metadata: Mapping[Any, Any] | None = None,
+        kw_only: bool = ...,
+    ) -> Any: ...
+
+else:
+    @overload  # `default` and `default_factory` are optional and mutually exclusive.
+    def field(
+        *,
+        default: _T,
+        init: bool = True,
+        repr: bool = True,
+        hash: bool | None = None,
+        compare: bool = True,
+        metadata: Mapping[Any, Any] | None = None,
+    ) -> _T: ...
+    @overload
+    def field(
+        *,
+        default_factory: Callable[[], _T],
+        init: bool = True,
+        repr: bool = True,
+        hash: bool | None = None,
+        compare: bool = True,
+        metadata: Mapping[Any, Any] | None = None,
+    ) -> _T: ...
+    @overload
+    def field(
+        *,
+        init: bool = True,
+        repr: bool = True,
+        hash: bool | None = None,
+        compare: bool = True,
+        metadata: Mapping[Any, Any] | None = None,
+    ) -> Any: ...
+
+def fields(
+    class_or_instance: DataclassInstance | type[DataclassInstance],
+) -> tuple[Field[Any], ...]: ...
+@overload
+def is_dataclass(obj: DataclassInstance) -> Literal[True]: ...
+@overload
+def is_dataclass(obj: type) -> TypeGuard[type[DataclassInstance]]: ...
+@overload
+def is_dataclass(
+    obj: object,
+) -> TypeGuard[DataclassInstance | type[DataclassInstance]]: ...
+
+class FrozenInstanceError(AttributeError): ...
+
+if sys.version_info >= (3, 9):
+    _InitVarMeta: TypeAlias = type
+else:
+    class _InitVarMeta(type):
+        # Not used, instead `InitVar.__class_getitem__` is called.
+        def __getitem__(self, params: Any) -> InitVar[Any]: ...
+
+class InitVar(Generic[_T], metaclass=_InitVarMeta):
+    type: Type[_T]
+    def __init__(self, type: Type[_T]) -> None: ...
+    if sys.version_info >= (3, 9):
+        @overload
+        def __class_getitem__(cls, type: Type[_T]) -> InitVar[_T]: ...
+        @overload
+        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...
+
+if sys.version_info >= (3, 12):
+    def make_dataclass(
+        cls_name: str,
+        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        *,
+        bases: tuple[type, ...] = (),
+        namespace: dict[str, Any] | None = None,
+        init: bool = True,
+        repr: bool = True,
+        eq: bool = True,
+        order: bool = False,
+        unsafe_hash: bool = False,
+        frozen: bool = False,
+        match_args: bool = True,
+        kw_only: bool = False,
+        slots: bool = False,
+        weakref_slot: bool = False,
+        module: str | None = None,
+    ) -> type: ...
+
+elif sys.version_info >= (3, 11):
+    def make_dataclass(
+        cls_name: str,
+        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        *,
+        bases: tuple[type, ...] = (),
+        namespace: dict[str, Any] | None = None,
+        init: bool = True,
+        repr: bool = True,
+        eq: bool = True,
+        order: bool = False,
+        unsafe_hash: bool = False,
+        frozen: bool = False,
+        match_args: bool = True,
+        kw_only: bool = False,
+        slots: bool = False,
+        weakref_slot: bool = False,
+    ) -> type: ...
+
+elif sys.version_info >= (3, 10):
+    def make_dataclass(
+        cls_name: str,
+        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        *,
+        bases: tuple[type, ...] = (),
+        namespace: dict[str, Any] | None = None,
+        init: bool = True,
+        repr: bool = True,
+        eq: bool = True,
+        order: bool = False,
+        unsafe_hash: bool = False,
+        frozen: bool = False,
+        match_args: bool = True,
+        kw_only: bool = False,
+        slots: bool = False,
+    ) -> type: ...
+
+else:
+    def make_dataclass(
+        cls_name: str,
+        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        *,
+        bases: tuple[type, ...] = (),
+        namespace: dict[str, Any] | None = None,
+        init: bool = True,
+        repr: bool = True,
+        eq: bool = True,
+        order: bool = False,
+        unsafe_hash: bool = False,
+        frozen: bool = False,
+    ) -> type: ...
+
+def replace(__obj: _DataclassT, **changes: Any) -> _DataclassT: ...

jaclang/vendor/mypy/typeshed/stdlib/datetime.pyi

@@ -0,0 +1,334 @@
+import sys
+from abc import abstractmethod
+from time import struct_time
+from typing import (
+    ClassVar,
+    Literal,
+    NamedTuple,
+    NoReturn,
+    SupportsIndex,
+    TypeVar,
+    final,
+    overload,
+)
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 11):
+    __all__ = (
+        "date",
+        "datetime",
+        "time",
+        "timedelta",
+        "timezone",
+        "tzinfo",
+        "MINYEAR",
+        "MAXYEAR",
+        "UTC",
+    )
+elif sys.version_info >= (3, 9):
+    __all__ = (
+        "date",
+        "datetime",
+        "time",
+        "timedelta",
+        "timezone",
+        "tzinfo",
+        "MINYEAR",
+        "MAXYEAR",
+    )
+
+_D = TypeVar("_D", bound=date)
+
+MINYEAR: Literal[1]
+MAXYEAR: Literal[9999]
+
+class tzinfo:
+    @abstractmethod
+    def tzname(self, __dt: datetime | None) -> str | None: ...
+    @abstractmethod
+    def utcoffset(self, __dt: datetime | None) -> timedelta | None: ...
+    @abstractmethod
+    def dst(self, __dt: datetime | None) -> timedelta | None: ...
+    def fromutc(self, __dt: datetime) -> datetime: ...
+
+# Alias required to avoid name conflicts with date(time).tzinfo.
+_TzInfo: TypeAlias = tzinfo
+
+@final
+class timezone(tzinfo):
+    utc: ClassVar[timezone]
+    min: ClassVar[timezone]
+    max: ClassVar[timezone]
+    def __init__(self, offset: timedelta, name: str = ...) -> None: ...
+    def tzname(self, __dt: datetime | None) -> str: ...
+    def utcoffset(self, __dt: datetime | None) -> timedelta: ...
+    def dst(self, __dt: datetime | None) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, __value: object) -> bool: ...
+
+if sys.version_info >= (3, 11):
+    UTC: timezone
+
+if sys.version_info >= (3, 9):
+    class _IsoCalendarDate(NamedTuple):
+        year: int
+        week: int
+        weekday: int
+
+class date:
+    min: ClassVar[date]
+    max: ClassVar[date]
+    resolution: ClassVar[timedelta]
+    def __new__(
+        cls, year: SupportsIndex, month: SupportsIndex, day: SupportsIndex
+    ) -> Self: ...
+    @classmethod
+    def fromtimestamp(cls, __timestamp: float) -> Self: ...
+    @classmethod
+    def today(cls) -> Self: ...
+    @classmethod
+    def fromordinal(cls, __n: int) -> Self: ...
+    @classmethod
+    def fromisoformat(cls, __date_string: str) -> Self: ...
+    @classmethod
+    def fromisocalendar(cls, year: int, week: int, day: int) -> Self: ...
+    @property
+    def year(self) -> int: ...
+    @property
+    def month(self) -> int: ...
+    @property
+    def day(self) -> int: ...
+    def ctime(self) -> str: ...
+    # On <3.12, the name of the parameter in the pure-Python implementation
+    # didn't match the name in the C implementation,
+    # meaning it is only *safe* to pass it as a keyword argument on 3.12+
+    if sys.version_info >= (3, 12):
+        def strftime(self, format: str) -> str: ...
+    else:
+        def strftime(self, __format: str) -> str: ...
+
+    def __format__(self, __fmt: str) -> str: ...
+    def isoformat(self) -> str: ...
+    def timetuple(self) -> struct_time: ...
+    def toordinal(self) -> int: ...
+    def replace(
+        self,
+        year: SupportsIndex = ...,
+        month: SupportsIndex = ...,
+        day: SupportsIndex = ...,
+    ) -> Self: ...
+    def __le__(self, __value: date) -> bool: ...
+    def __lt__(self, __value: date) -> bool: ...
+    def __ge__(self, __value: date) -> bool: ...
+    def __gt__(self, __value: date) -> bool: ...
+    def __eq__(self, __value: object) -> bool: ...
+    def __add__(self, __value: timedelta) -> Self: ...
+    def __radd__(self, __value: timedelta) -> Self: ...
+    @overload
+    def __sub__(self, __value: timedelta) -> Self: ...
+    @overload
+    def __sub__(self, __value: datetime) -> NoReturn: ...
+    @overload
+    def __sub__(self: _D, __value: _D) -> timedelta: ...
+    def __hash__(self) -> int: ...
+    def weekday(self) -> int: ...
+    def isoweekday(self) -> int: ...
+    if sys.version_info >= (3, 9):
+        def isocalendar(self) -> _IsoCalendarDate: ...
+    else:
+        def isocalendar(self) -> tuple[int, int, int]: ...
+
+class time:
+    min: ClassVar[time]
+    max: ClassVar[time]
+    resolution: ClassVar[timedelta]
+    def __new__(
+        cls,
+        hour: SupportsIndex = ...,
+        minute: SupportsIndex = ...,
+        second: SupportsIndex = ...,
+        microsecond: SupportsIndex = ...,
+        tzinfo: _TzInfo | None = ...,
+        *,
+        fold: int = ...,
+    ) -> Self: ...
+    @property
+    def hour(self) -> int: ...
+    @property
+    def minute(self) -> int: ...
+    @property
+    def second(self) -> int: ...
+    @property
+    def microsecond(self) -> int: ...
+    @property
+    def tzinfo(self) -> _TzInfo | None: ...
+    @property
+    def fold(self) -> int: ...
+    def __le__(self, __value: time) -> bool: ...
+    def __lt__(self, __value: time) -> bool: ...
+    def __ge__(self, __value: time) -> bool: ...
+    def __gt__(self, __value: time) -> bool: ...
+    def __eq__(self, __value: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def isoformat(self, timespec: str = ...) -> str: ...
+    @classmethod
+    def fromisoformat(cls, __time_string: str) -> Self: ...
+    # On <3.12, the name of the parameter in the pure-Python implementation
+    # didn't match the name in the C implementation,
+    # meaning it is only *safe* to pass it as a keyword argument on 3.12+
+    if sys.version_info >= (3, 12):
+        def strftime(self, format: str) -> str: ...
+    else:
+        def strftime(self, __format: str) -> str: ...
+
+    def __format__(self, __fmt: str) -> str: ...
+    def utcoffset(self) -> timedelta | None: ...
+    def tzname(self) -> str | None: ...
+    def dst(self) -> timedelta | None: ...
+    def replace(
+        self,
+        hour: SupportsIndex = ...,
+        minute: SupportsIndex = ...,
+        second: SupportsIndex = ...,
+        microsecond: SupportsIndex = ...,
+        tzinfo: _TzInfo | None = ...,
+        *,
+        fold: int = ...,
+    ) -> Self: ...
+
+_Date: TypeAlias = date
+_Time: TypeAlias = time
+
+class timedelta:
+    min: ClassVar[timedelta]
+    max: ClassVar[timedelta]
+    resolution: ClassVar[timedelta]
+    def __new__(
+        cls,
+        days: float = ...,
+        seconds: float = ...,
+        microseconds: float = ...,
+        milliseconds: float = ...,
+        minutes: float = ...,
+        hours: float = ...,
+        weeks: float = ...,
+    ) -> Self: ...
+    @property
+    def days(self) -> int: ...
+    @property
+    def seconds(self) -> int: ...
+    @property
+    def microseconds(self) -> int: ...
+    def total_seconds(self) -> float: ...
+    def __add__(self, __value: timedelta) -> timedelta: ...
+    def __radd__(self, __value: timedelta) -> timedelta: ...
+    def __sub__(self, __value: timedelta) -> timedelta: ...
+    def __rsub__(self, __value: timedelta) -> timedelta: ...
+    def __neg__(self) -> timedelta: ...
+    def __pos__(self) -> timedelta: ...
+    def __abs__(self) -> timedelta: ...
+    def __mul__(self, __value: float) -> timedelta: ...
+    def __rmul__(self, __value: float) -> timedelta: ...
+    @overload
+    def __floordiv__(self, __value: timedelta) -> int: ...
+    @overload
+    def __floordiv__(self, __value: int) -> timedelta: ...
+    @overload
+    def __truediv__(self, __value: timedelta) -> float: ...
+    @overload
+    def __truediv__(self, __value: float) -> timedelta: ...
+    def __mod__(self, __value: timedelta) -> timedelta: ...
+    def __divmod__(self, __value: timedelta) -> tuple[int, timedelta]: ...
+    def __le__(self, __value: timedelta) -> bool: ...
+    def __lt__(self, __value: timedelta) -> bool: ...
+    def __ge__(self, __value: timedelta) -> bool: ...
+    def __gt__(self, __value: timedelta) -> bool: ...
+    def __eq__(self, __value: object) -> bool: ...
+    def __bool__(self) -> bool: ...
+    def __hash__(self) -> int: ...
+
+class datetime(date):
+    min: ClassVar[datetime]
+    max: ClassVar[datetime]
+    def __new__(
+        cls,
+        year: SupportsIndex,
+        month: SupportsIndex,
+        day: SupportsIndex,
+        hour: SupportsIndex = ...,
+        minute: SupportsIndex = ...,
+        second: SupportsIndex = ...,
+        microsecond: SupportsIndex = ...,
+        tzinfo: _TzInfo | None = ...,
+        *,
+        fold: int = ...,
+    ) -> Self: ...
+    @property
+    def hour(self) -> int: ...
+    @property
+    def minute(self) -> int: ...
+    @property
+    def second(self) -> int: ...
+    @property
+    def microsecond(self) -> int: ...
+    @property
+    def tzinfo(self) -> _TzInfo | None: ...
+    @property
+    def fold(self) -> int: ...
+    # On <3.12, the name of the first parameter in the pure-Python implementation
+    # didn't match the name in the C implementation,
+    # meaning it is only *safe* to pass it as a keyword argument on 3.12+
+    if sys.version_info >= (3, 12):
+        @classmethod
+        def fromtimestamp(cls, timestamp: float, tz: _TzInfo | None = ...) -> Self: ...
+    else:
+        @classmethod
+        def fromtimestamp(
+            cls, __timestamp: float, tz: _TzInfo | None = ...
+        ) -> Self: ...
+
+    @classmethod
+    def utcfromtimestamp(cls, __t: float) -> Self: ...
+    @classmethod
+    def now(cls, tz: _TzInfo | None = None) -> Self: ...
+    @classmethod
+    def utcnow(cls) -> Self: ...
+    @classmethod
+    def combine(
+        cls, date: _Date, time: _Time, tzinfo: _TzInfo | None = ...
+    ) -> Self: ...
+    def timestamp(self) -> float: ...
+    def utctimetuple(self) -> struct_time: ...
+    def date(self) -> _Date: ...
+    def time(self) -> _Time: ...
+    def timetz(self) -> _Time: ...
+    def replace(
+        self,
+        year: SupportsIndex = ...,
+        month: SupportsIndex = ...,
+        day: SupportsIndex = ...,
+        hour: SupportsIndex = ...,
+        minute: SupportsIndex = ...,
+        second: SupportsIndex = ...,
+        microsecond: SupportsIndex = ...,
+        tzinfo: _TzInfo | None = ...,
+        *,
+        fold: int = ...,
+    ) -> Self: ...
+    def astimezone(self, tz: _TzInfo | None = ...) -> Self: ...
+    def isoformat(self, sep: str = ..., timespec: str = ...) -> str: ...
+    @classmethod
+    def strptime(cls, __date_string: str, __format: str) -> Self: ...
+    def utcoffset(self) -> timedelta | None: ...
+    def tzname(self) -> str | None: ...
+    def dst(self) -> timedelta | None: ...
+    def __le__(self, __value: datetime) -> bool: ...  # type: ignore[override]
+    def __lt__(self, __value: datetime) -> bool: ...  # type: ignore[override]
+    def __ge__(self, __value: datetime) -> bool: ...  # type: ignore[override]
+    def __gt__(self, __value: datetime) -> bool: ...  # type: ignore[override]
+    def __eq__(self, __value: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    @overload  # type: ignore[override]
+    def __sub__(self, __value: timedelta) -> Self: ...
+    @overload
+    def __sub__(self: _D, __value: _D) -> timedelta: ...