basedpyright 1.28.4 → 1.28.5

package/dist/typeshed-fallback/stubs/icalendar/icalendar/prop.pyi

@@ -1,9 +1,9 @@
 import datetime
-from _typeshed import Incomplete, Unused
-from collections.abc import Iterator
+from _typeshed import ConvertibleToFloat, ConvertibleToInt, SupportsKeysAndGetItem, Unused
+from collections.abc import Iterable, Iterator
 from enum import Enum
 from re import Pattern
-from typing import Any, ClassVar, Final, TypeVar, overload
+from typing import Any, ClassVar, Final, Literal, Protocol, SupportsIndex, overload
 from typing_extensions import Self, TypeAlias
 
 from .caselessdict import CaselessDict
@@ -44,70 +44,80 @@ __all__ = [
 ]
 
 _PropType: TypeAlias = type[Any]  # any of the v* classes in this file
-_vRecurT = TypeVar("_vRecurT", bound=vRecur)
+_PeriodTuple: TypeAlias = tuple[datetime.datetime, datetime.datetime | datetime.timedelta]
+_AnyTimeType: TypeAlias = datetime.datetime | datetime.date | datetime.timedelta | datetime.time | _PeriodTuple
+
+class _vType(Protocol):
+    def to_ical(self) -> bytes | str: ...
 
 DURATION_REGEX: Final[Pattern[str]]
 WEEKDAY_RULE: Final[Pattern[str]]
 
 class vBinary:
-    obj: Incomplete
+    obj: str
     params: Parameters
-    def __init__(self, obj) -> None: ...
+    def __init__(self, obj: str | bytes) -> None: ...
     def to_ical(self) -> bytes: ...
     @staticmethod
-    def from_ical(ical): ...
-    def __eq__(self, other): ...
+    def from_ical(ical: ICAL_TYPE) -> bytes: ...
+    def __eq__(self, other: object) -> bool: ...
 
 class vBoolean(int):
-    BOOL_MAP: Incomplete
+    BOOL_MAP: Final[CaselessDict[bool]]
     params: Parameters
-    def __new__(cls, *args, **kwargs): ...
-    def to_ical(self) -> bytes: ...
+    def __new__(cls, x: ConvertibleToInt = ..., /, *, params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
+    def to_ical(self) -> Literal[b"TRUE", b"FALSE"]: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: ICAL_TYPE) -> bool: ...
 
 class vText(str):
     encoding: str
     params: Parameters
-    def __new__(cls, value: ICAL_TYPE, encoding: str = "utf-8") -> Self: ...
+    def __new__(cls, value: ICAL_TYPE, encoding: str = "utf-8", params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
 
 class vCalAddress(str):
     params: Parameters
-    def __new__(cls, value, encoding="utf-8"): ...
+    def __new__(cls, value: ICAL_TYPE, encoding="utf-8", params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
+    @property
+    def email(self) -> str: ...
+    @property
+    def name(self) -> str: ...
+    @name.setter
+    def name(self, value: str) -> None: ...
 
 class vFloat(float):
     params: Parameters
-    def __new__(cls, *args, **kwargs): ...
+    def __new__(cls, x: ConvertibleToFloat = ..., /, *, params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
 
 class vInt(int):
     params: Parameters
-    def __new__(cls, *args, **kwargs): ...
+    def __new__(cls, x: ConvertibleToInt = ..., /, *, params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
 
 class vDDDLists:
     params: Parameters
-    dts: Incomplete
-    def __init__(self, dt_list) -> None: ...
+    dts: list[vDDDTypes]
+    def __init__(self, dt_list: Iterable[_AnyTimeType] | _AnyTimeType) -> None: ...
     def to_ical(self) -> bytes: ...
     @staticmethod
-    def from_ical(ical, timezone: Incomplete | None = None): ...
-    def __eq__(self, other): ...
+    def from_ical(ical: str, timezone: str | datetime.timezone | None = None): ...
+    def __eq__(self, other: object) -> bool: ...
 
 class vCategory:
-    cats: Incomplete
+    cats: list[vText]
     params: Parameters
-    def __init__(self, c_list) -> None: ...
+    def __init__(self, c_list: Iterable[ICAL_TYPE] | ICAL_TYPE, params: SupportsKeysAndGetItem[str, str] = {}) -> None: ...
     def __iter__(self) -> Iterator[str]: ...
     def to_ical(self) -> bytes: ...
     @staticmethod
@@ -116,80 +126,95 @@ class vCategory:
 
 class TimeBase:
     def __eq__(self, other: object) -> bool: ...
-    def __hash__(self): ...
+    def __hash__(self) -> int: ...
 
 class vDDDTypes(TimeBase):
     params: Parameters
-    dt: Incomplete
-    def __init__(self, dt) -> None: ...
+    dt: _AnyTimeType
+    def __init__(self, dt: _AnyTimeType) -> None: ...
     def to_ical(self) -> bytes: ...
+    @overload
     @classmethod
-    def from_ical(cls, ical, timezone: Incomplete | None = None): ...
+    def from_ical(cls, ical: Self, timezone: Unused | None = None) -> _AnyTimeType: ...
+    # Return type is one of vDuration, vPeriod, vDatetime, vDate, or vTime,
+    # depending on the ical string.
+    @overload
+    @classmethod
+    def from_ical(cls, ical: str, timezone: datetime.timezone | str | None = None) -> Any: ...
 
 class vDate(TimeBase):
-    dt: Incomplete
+    dt: datetime.date
     params: Parameters
-    def __init__(self, dt) -> None: ...
+    def __init__(self, dt: datetime.date) -> None: ...
     def to_ical(self) -> bytes: ...
     @staticmethod
-    def from_ical(ical): ...
+    def from_ical(ical: ICAL_TYPE) -> datetime.date: ...
 
 class vDatetime(TimeBase):
-    dt: Incomplete
+    dt: datetime.datetime
     params: Parameters
-    def __init__(self, dt) -> None: ...
+    def __init__(self, dt: datetime.datetime, params: SupportsKeysAndGetItem[str, str] = {}) -> None: ...
     def to_ical(self) -> bytes: ...
     @staticmethod
-    def from_ical(ical, timezone: datetime.timezone | str | None = None) -> datetime.datetime: ...
+    def from_ical(ical: ICAL_TYPE, timezone: datetime.timezone | str | None = None) -> datetime.datetime: ...
 
 class vDuration(TimeBase):
-    td: Incomplete
+    td: datetime.timedelta
     params: Parameters
-    def __init__(self, td) -> None: ...
+    def __init__(self, td: datetime.timedelta, params: SupportsKeysAndGetItem[str, str] = {}) -> None: ...
     def to_ical(self) -> bytes: ...
     @staticmethod
-    def from_ical(ical): ...
+    def from_ical(ical: str) -> datetime.timedelta: ...
     @property
-    def dt(self): ...
+    def dt(self) -> datetime.timedelta: ...
 
 class vPeriod(TimeBase):
     params: Parameters
-    start: Incomplete
-    end: Incomplete
-    by_duration: Incomplete
-    duration: Incomplete
-    def __init__(self, per) -> None: ...
-    def overlaps(self, other): ...
+    start: datetime.datetime
+    end: datetime.datetime
+    by_duration: bool
+    duration: datetime.timedelta
+    def __init__(self, per: _PeriodTuple) -> None: ...
+    def overlaps(self, other: vPeriod) -> bool: ...
     def to_ical(self) -> bytes: ...
+    # Return type is a tuple of vDuration, vPeriod, vDatetime, vDate, or vTime,
+    # depending on the ical string. If the ical string is formed according to
+    # the iCalendar specification, this should always return a
+    # (datetime, datetime) or a (datetime, timedelta) tuple, but this is not
+    # enforced.
     @staticmethod
-    def from_ical(ical, timezone: Incomplete | None = None): ...
+    def from_ical(ical: str, timezone: datetime.timezone | str | None = None) -> tuple[Any, Any]: ...
     @property
-    def dt(self): ...
+    def dt(self) -> _PeriodTuple: ...
 
 class vWeekday(str):
-    week_days: Incomplete
-    relative: Incomplete
+    week_days: Final[CaselessDict[int]]
+    weekday: Literal["SU", "MO", "TU", "WE", "TH", "FR", "SA"] | None
+    relative: int | None
     params: Parameters
-    def __new__(cls, value, encoding="utf-8"): ...
+    def __new__(cls, value: ICAL_TYPE, encoding: str = "utf-8", params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
 
 class vFrequency(str):
-    frequencies: Incomplete
+    frequencies: Final[CaselessDict[str]]
     params: Parameters
-    def __new__(cls, value, encoding="utf-8"): ...
+    def __new__(cls, value: ICAL_TYPE, encoding: str = "utf-8", params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
 
 class vMonth(int):
-    leap: bool
     params: Parameters
-    def __new__(cls, month: vMonth | str | int) -> Self: ...
+    def __new__(cls, month: vMonth | str | int, params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical: vMonth | str | int) -> Self: ...
+    @property
+    def leap(self) -> bool: ...
+    @leap.setter
+    def leap(self, value: bool) -> None: ...
 
 class vSkip(vText, Enum):
     OMIT = "OMIT"
@@ -198,69 +223,82 @@ class vSkip(vText, Enum):
 
     def __reduce_ex__(self, proto: Unused) -> tuple[Any, ...]: ...
 
-class vRecur(CaselessDict[Incomplete]):
-    frequencies: ClassVar[list[str]]
-    canonical_order: ClassVar[tuple[str, ...]]
-    types: ClassVar[CaselessDict[_PropType]]
+# The type of the values depend on the key. Each key maps to a v* class, and
+# the allowed types are the types that the corresponding v* class can parse.
+class vRecur(CaselessDict[Iterable[Any] | Any]):
     params: Parameters
-    def __init__(self, *args, **kwargs) -> None: ...
+    frequencies: Final[list[str]]
+    canonical_order: ClassVar[tuple[str, ...]]
+    types: Final[CaselessDict[_PropType]]
+    def __init__(
+        self, *args, params: SupportsKeysAndGetItem[str, str] = {}, **kwargs: list[Any] | tuple[Any, ...] | Any
+    ) -> None: ...
     def to_ical(self) -> bytes: ...
     @classmethod
-    def parse_type(cls, key, values): ...
+    def parse_type(cls, key: str, values: str) -> list[Any]: ...  # Returns a list of v* objects
     @classmethod
-    @overload
-    def from_ical(cls, ical: _vRecurT) -> _vRecurT: ...
-    @classmethod
-    @overload
-    def from_ical(cls, ical: str) -> Self: ...
+    def from_ical(cls, ical: vRecur | str) -> Self: ...
 
 class vTime(TimeBase):
-    dt: Incomplete
+    dt: datetime.time | datetime.datetime
     params: Parameters
-    def __init__(self, *args) -> None: ...
-    def to_ical(self) -> bytes: ...
+    @overload
+    def __init__(self, dt: datetime.time | datetime.datetime, /) -> None: ...
+    # args are passed to the datetime.time() constructor
+    @overload
+    def __init__(
+        self,
+        hour: SupportsIndex = ...,
+        minute: SupportsIndex = ...,
+        second: SupportsIndex = ...,
+        microsecond: SupportsIndex = ...,
+        tzinfo: datetime.tzinfo | None = ...,
+        /,
+    ) -> None: ...
+    def to_ical(self) -> str: ...
     @staticmethod
-    def from_ical(ical): ...
+    def from_ical(ical: ICAL_TYPE) -> datetime.time: ...
 
 class vUri(str):
     params: Parameters
-    def __new__(cls, value, encoding="utf-8"): ...
+    def __new__(cls, value: ICAL_TYPE, encoding: str = "utf-8", params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
 
 class vGeo:
-    latitude: Incomplete
-    longitude: Incomplete
+    latitude: float
+    longitude: float
     params: Parameters
-    def __init__(self, geo) -> None: ...
-    def to_ical(self) -> bytes: ...
+    def __init__(self, geo: tuple[float | str, float | str], params: SupportsKeysAndGetItem[str, str] = {}) -> None: ...
+    def to_ical(self) -> str: ...
     @staticmethod
-    def from_ical(ical): ...
-    def __eq__(self, other): ...
+    def from_ical(ical: str) -> tuple[float, float]: ...
+    def __eq__(self, other: _vType) -> bool: ...  # type: ignore[override]
 
 class vUTCOffset:
     ignore_exceptions: bool
     td: datetime.timedelta
     params: Parameters
-    def __init__(self, td: datetime.timedelta) -> None: ...
-    def to_ical(self) -> bytes: ...
+    def __init__(self, td: datetime.timedelta, params: SupportsKeysAndGetItem[str, str] = {}) -> None: ...
+    def to_ical(self) -> str: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: Self | ICAL_TYPE) -> datetime.timedelta: ...
     def __eq__(self, other: object) -> bool: ...
     def __hash__(self) -> int: ...
 
 class vInline(str):
     params: Parameters
-    def __new__(cls, value, encoding="utf-8"): ...
+    def __new__(cls, value: ICAL_TYPE, encoding: str = "utf-8", params: SupportsKeysAndGetItem[str, str] = {}) -> Self: ...
     def to_ical(self) -> bytes: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
 
 class TypesFactory(CaselessDict[_PropType]):
     all_types: tuple[_PropType, ...]
-    def __init__(self, *args, **kwargs) -> None: ...
     types_map: CaselessDict[str]
     def for_property(self, name: str) -> _PropType: ...
-    def to_ical(self, name: str, value) -> bytes: ...
-    def from_ical(self, name: str, value): ...
+    # value is str | bytes, depending on what the v* class supports
+    def to_ical(self, name: str, value: Any) -> bytes: ...
+    # value and return type depend on what the v* class supports
+    def from_ical(self, name: str, value: Any) -> Any: ...

package/dist/typeshed-fallback/stubs/icalendar/icalendar/timezone/equivalent_timezone_ids.pyi

@@ -4,12 +4,10 @@ from typing import Final
 
 __all__ = ["main"]
 
-def check(dt: datetime.datetime, tz: datetime.tzinfo) -> tuple[datetime.datetime, datetime.timedelta]: ...
-def checks(tz: datetime.tzinfo) -> list[tuple[datetime.datetime, datetime.timedelta]]: ...
-
 START: Final[datetime.datetime]
 END: Final[datetime.datetime]
+DISTANCE_FROM_TIMEZONE_CHANGE: Final[datetime.timedelta]
 
 DTS: Final[list[datetime.datetime]]
 
-def main(create_timezones: list[Callable[[str], datetime.tzinfo]], name: str, pool_size: int = ...) -> None: ...
+def main(create_timezones: list[Callable[[str], datetime.tzinfo]], name: str) -> None: ...

package/dist/typeshed-fallback/stubs/icalendar/icalendar/timezone/tzid.pyi

@@ -5,4 +5,3 @@ __all__ = ["tzid_from_tzinfo", "tzid_from_dt", "tzids_from_tzinfo"]
 def tzids_from_tzinfo(tzinfo: datetime.tzinfo | None) -> tuple[str, ...]: ...
 def tzid_from_tzinfo(tzinfo: datetime.tzinfo | None) -> str | None: ...
 def tzid_from_dt(dt: datetime.datetime) -> str | None: ...
-def tzinfo2tzids(tzinfo: datetime.tzinfo | None) -> set[str]: ...

package/dist/typeshed-fallback/stubs/icalendar/icalendar/timezone/zoneinfo.pyi

@@ -1,14 +1,9 @@
 import datetime
-import sys
 from typing import Final, Literal
+from zoneinfo import ZoneInfo
 
 from dateutil.rrule import rrule, rruleset
 
-if sys.version_info >= (3, 9):
-    from zoneinfo import ZoneInfo
-else:
-    from backports.zoneinfo import ZoneInfo
-
 from ..cal import Timezone
 from ..prop import vRecur
 from .provider import TZProvider

package/dist/typeshed-fallback/stubs/jwcrypto/jwcrypto/common.pyi

@@ -1,7 +1,9 @@
-from _typeshed import Incomplete
-from collections.abc import Iterator, MutableMapping
+from collections.abc import Callable, Iterator, MutableMapping
 from typing import Any, NamedTuple
 
+from jwcrypto.jwe import JWE
+from jwcrypto.jws import JWS
+
 def base64url_encode(payload: str | bytes) -> str: ...
 def base64url_decode(payload: str) -> bytes: ...
 def json_encode(string: str | bytes) -> str: ...
@@ -36,11 +38,11 @@ class JWSEHeaderParameter(NamedTuple):
     description: str
     mustprotect: bool
     supported: bool
-    check_fn: Incomplete | None
+    check_fn: Callable[[JWS | JWE], bool] | None
 
 class JWSEHeaderRegistry(MutableMapping[str, JWSEHeaderParameter]):
-    def __init__(self, init_registry: Incomplete | None = None) -> None: ...
-    def check_header(self, h: str, value) -> bool: ...
+    def __init__(self, init_registry: dict[str, JWSEHeaderParameter] | None = None) -> None: ...
+    def check_header(self, h: str, value: JWS | JWE) -> bool: ...
     def __getitem__(self, key: str) -> JWSEHeaderParameter: ...
     def __iter__(self) -> Iterator[str]: ...
     def __delitem__(self, key: str) -> None: ...

package/dist/typeshed-fallback/stubs/jwcrypto/jwcrypto/jwe.pyi

@@ -1,8 +1,10 @@
 from _typeshed import Incomplete
 from collections.abc import Mapping, Sequence
+from typing import Any
+from typing_extensions import Self
 
 from jwcrypto import common
-from jwcrypto.common import JWException, JWSEHeaderParameter
+from jwcrypto.common import JWException, JWSEHeaderParameter, JWSEHeaderRegistry
 from jwcrypto.jwk import JWK, JWKSet
 
 default_max_compressed_size: int
@@ -18,34 +20,34 @@ InvalidJWEKeyType = common.InvalidJWEKeyType
 InvalidJWEOperation = common.InvalidJWEOperation
 
 class JWE:
-    objects: Incomplete
-    plaintext: Incomplete
-    header_registry: Incomplete
+    objects: dict[str, Any]
+    plaintext: bytes | None
+    header_registry: JWSEHeaderRegistry
     cek: Incomplete
-    decryptlog: Incomplete
+    decryptlog: list[str] | None
     def __init__(
         self,
-        plaintext: bytes | None = None,
+        plaintext: str | bytes | None = None,
         protected: str | None = None,
         unprotected: str | None = None,
         aad: bytes | None = None,
-        algs: Incomplete | None = None,
+        algs: list[str] | None = None,
         recipient: str | None = None,
-        header: Incomplete | None = None,
-        header_registry: Incomplete | None = None,
+        header: str | None = None,
+        header_registry: Mapping[str, JWSEHeaderParameter] | None = None,
     ) -> None: ...
     @property
-    def allowed_algs(self): ...
+    def allowed_algs(self) -> list[str]: ...
     @allowed_algs.setter
-    def allowed_algs(self, algs) -> None: ...
-    def add_recipient(self, key, header: Incomplete | None = None) -> None: ...
-    def serialize(self, compact: bool = False): ...
+    def allowed_algs(self, algs: list[str]) -> None: ...
+    def add_recipient(self, key: JWK, header: dict[str, Any] | str | None = None) -> None: ...
+    def serialize(self, compact: bool = False) -> str: ...
     def decrypt(self, key: JWK | JWKSet) -> None: ...
     def deserialize(self, raw_jwe: str | bytes, key: JWK | JWKSet | None = None) -> None: ...
     @property
-    def payload(self): ...
+    def payload(self) -> bytes: ...
     @property
     def jose_header(self) -> dict[Incomplete, Incomplete]: ...
     @classmethod
-    def from_jose_token(cls, token: str | bytes) -> JWE: ...
+    def from_jose_token(cls, token: str | bytes) -> Self: ...
     def __eq__(self, other: object) -> bool: ...