jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/curses/ascii.pyi

@@ -1,62 +0,0 @@
-from typing import TypeVar
-
-_CharT = TypeVar("_CharT", str, int)
-
-NUL: int
-SOH: int
-STX: int
-ETX: int
-EOT: int
-ENQ: int
-ACK: int
-BEL: int
-BS: int
-TAB: int
-HT: int
-LF: int
-NL: int
-VT: int
-FF: int
-CR: int
-SO: int
-SI: int
-DLE: int
-DC1: int
-DC2: int
-DC3: int
-DC4: int
-NAK: int
-SYN: int
-ETB: int
-CAN: int
-EM: int
-SUB: int
-ESC: int
-FS: int
-GS: int
-RS: int
-US: int
-SP: int
-DEL: int
-
-controlnames: list[int]
-
-def isalnum(c: str | int) -> bool: ...
-def isalpha(c: str | int) -> bool: ...
-def isascii(c: str | int) -> bool: ...
-def isblank(c: str | int) -> bool: ...
-def iscntrl(c: str | int) -> bool: ...
-def isdigit(c: str | int) -> bool: ...
-def isgraph(c: str | int) -> bool: ...
-def islower(c: str | int) -> bool: ...
-def isprint(c: str | int) -> bool: ...
-def ispunct(c: str | int) -> bool: ...
-def isspace(c: str | int) -> bool: ...
-def isupper(c: str | int) -> bool: ...
-def isxdigit(c: str | int) -> bool: ...
-def isctrl(c: str | int) -> bool: ...
-def ismeta(c: str | int) -> bool: ...
-def ascii(c: _CharT) -> _CharT: ...
-def ctrl(c: _CharT) -> _CharT: ...
-def alt(c: _CharT) -> _CharT: ...
-def unctrl(c: str | int) -> str: ...

jaclang/vendor/mypy/typeshed/stdlib/curses/has_key.pyi

@@ -1 +0,0 @@
-def has_key(ch: int | str) -> bool: ...

jaclang/vendor/mypy/typeshed/stdlib/curses/panel.pyi

@@ -1,22 +0,0 @@
-from _curses import _CursesWindow
-
-version: str
-
-class _Curses_Panel:  # type is <class '_curses_panel.curses panel'> (note the space in the class name)
-    def above(self) -> _Curses_Panel: ...
-    def below(self) -> _Curses_Panel: ...
-    def bottom(self) -> None: ...
-    def hidden(self) -> bool: ...
-    def hide(self) -> None: ...
-    def move(self, y: int, x: int) -> None: ...
-    def replace(self, win: _CursesWindow) -> None: ...
-    def set_userptr(self, obj: object) -> None: ...
-    def show(self) -> None: ...
-    def top(self) -> None: ...
-    def userptr(self) -> object: ...
-    def window(self) -> _CursesWindow: ...
-
-def bottom_panel() -> _Curses_Panel: ...
-def new_panel(win: _CursesWindow, /) -> _Curses_Panel: ...
-def top_panel() -> _Curses_Panel: ...
-def update_panels() -> _Curses_Panel: ...

jaclang/vendor/mypy/typeshed/stdlib/curses/textpad.pyi

@@ -1,11 +0,0 @@
-from _curses import _CursesWindow
-from collections.abc import Callable
-
-def rectangle(win: _CursesWindow, uly: int, ulx: int, lry: int, lrx: int) -> None: ...
-
-class Textbox:
-    stripspaces: bool
-    def __init__(self, win: _CursesWindow, insert_mode: bool = False) -> None: ...
-    def edit(self, validate: Callable[[int], int] | None = None) -> str: ...
-    def do_command(self, ch: str | int) -> None: ...
-    def gather(self) -> str: ...

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

@@ -1,315 +0,0 @@
-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.
-        # pyright ignore is needed because pyright (not unreasonably) thinks this
-        # is an invalid use of InitVar.
-        def __getitem__(self, params: Any) -> InitVar[Any]: ...  # pyright: ignore
-
-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]: ...  # pyright: ignore
-        @overload
-        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...  # pyright: ignore
-
-if sys.version_info >= (3, 12):
-    def make_dataclass(
-        cls_name: str,
-        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, 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, Any] | tuple[str, Any, 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, Any] | tuple[str, Any, 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, Any] | tuple[str, Any, 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

@@ -1,295 +0,0 @@
-import sys
-from abc import abstractmethod
-from time import struct_time
-from typing import ClassVar, Literal, NamedTuple, NoReturn, SupportsIndex, final, overload
-from typing_extensions import Self, TypeAlias, deprecated
-
-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")
-
-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: datetime, /) -> NoReturn: ...
-    @overload
-    def __sub__(self, value: Self, /) -> timedelta: ...
-    @overload
-    def __sub__(self, value: timedelta, /) -> Self: ...
-    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
-    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .fromtimestamp(datetime.UTC)")
-    def utcfromtimestamp(cls, t: float, /) -> Self: ...
-    @classmethod
-    def now(cls, tz: _TzInfo | None = None) -> Self: ...
-    @classmethod
-    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .now(datetime.UTC)")
-    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: Self, /) -> timedelta: ...
-    @overload
-    def __sub__(self, value: timedelta, /) -> Self: ...