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

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

@@ -0,0 +1,62 @@
+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

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

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,315 @@
+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

@@ -0,0 +1,295 @@
+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: ...