basedpyright 1.18.3 → 1.18.4

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

@@ -1,137 +1,166 @@
 import datetime
-from _typeshed import Incomplete
-from datetime import tzinfo
+from _typeshed import Incomplete, Unused
+from collections.abc import Iterator
+from enum import Enum
 from re import Pattern
-from typing import Any, ClassVar, Final
-from typing_extensions import TypeAlias
+from typing import Any, ClassVar, Final, TypeVar, overload
+from typing_extensions import Self, TypeAlias
 
 from .caselessdict import CaselessDict
 from .parser import Parameters
+from .parser_tools import ICAL_TYPE
+
+__all__ = [
+    "DURATION_REGEX",
+    "TimeBase",
+    "TypesFactory",
+    "WEEKDAY_RULE",
+    "tzid_from_dt",
+    "vBinary",
+    "vBoolean",
+    "vCalAddress",
+    "vCategory",
+    "vDDDLists",
+    "vDDDTypes",
+    "vDate",
+    "vDatetime",
+    "vDuration",
+    "vFloat",
+    "vFrequency",
+    "vGeo",
+    "vInline",
+    "vInt",
+    "vMonth",
+    "vPeriod",
+    "vRecur",
+    "vSkip",
+    "vText",
+    "vTime",
+    "vUTCOffset",
+    "vUri",
+    "vWeekday",
+]
 
 _PropType: TypeAlias = type[Any]  # any of the v* classes in this file
+_vRecurT = TypeVar("_vRecurT", bound=vRecur)
 
 DURATION_REGEX: Final[Pattern[str]]
 WEEKDAY_RULE: Final[Pattern[str]]
-ZERO: Final[datetime.timedelta]
-HOUR: Final[datetime.timedelta]
-STDOFFSET: Final[datetime.timedelta]
-DSTOFFSET: Final[datetime.timedelta]
-DSTDIFF: Final[datetime.timedelta]
-
-class FixedOffset(tzinfo):
-    def __init__(self, offset, name) -> None: ...
-    def utcoffset(self, dt): ...
-    def tzname(self, dt): ...
-    def dst(self, dt): ...
-
-class LocalTimezone(tzinfo):
-    def utcoffset(self, dt): ...
-    def dst(self, dt): ...
-    def tzname(self, dt): ...
+
+def tzid_from_dt(dt: datetime.datetime) -> str | None: ...
 
 class vBinary:
     obj: Incomplete
-    params: Incomplete
+    params: Parameters
     def __init__(self, obj) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
     def from_ical(ical): ...
     def __eq__(self, other): ...
 
 class vBoolean(int):
     BOOL_MAP: Incomplete
-    params: Incomplete
+    params: Parameters
     def __new__(cls, *args, **kwargs): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical): ...
 
+class vText(str):
+    encoding: str
+    params: Parameters
+    def __new__(cls, value: ICAL_TYPE, encoding: str = "utf-8") -> Self: ...
+    def to_ical(self) -> bytes: ...
+    @classmethod
+    def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
+
 class vCalAddress(str):
-    params: Incomplete
+    params: Parameters
     def __new__(cls, value, encoding="utf-8"): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical): ...
 
 class vFloat(float):
-    params: Incomplete
+    params: Parameters
     def __new__(cls, *args, **kwargs): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical): ...
 
 class vInt(int):
-    params: Incomplete
+    params: Parameters
     def __new__(cls, *args, **kwargs): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    def from_ical(cls, ical: ICAL_TYPE) -> Self: ...
 
 class vDDDLists:
-    params: Incomplete
+    params: Parameters
     dts: Incomplete
     def __init__(self, dt_list) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
     def from_ical(ical, timezone: Incomplete | None = None): ...
     def __eq__(self, other): ...
 
 class vCategory:
     cats: Incomplete
-    params: Incomplete
+    params: Parameters
     def __init__(self, c_list) -> None: ...
-    def to_ical(self): ...
+    def __iter__(self) -> Iterator[str]: ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
-    def from_ical(ical): ...
-    def __eq__(self, other): ...
+    def from_ical(ical: ICAL_TYPE) -> str: ...
+    def __eq__(self, other: object) -> bool: ...
 
 class TimeBase:
-    def __eq__(self, other): ...
+    def __eq__(self, other: object) -> bool: ...
     def __hash__(self): ...
 
 class vDDDTypes(TimeBase):
-    params: Incomplete
+    params: Parameters
     dt: Incomplete
     def __init__(self, dt) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical, timezone: Incomplete | None = None): ...
 
 class vDate(TimeBase):
     dt: Incomplete
-    params: Incomplete
+    params: Parameters
     def __init__(self, dt) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
     def from_ical(ical): ...
 
 class vDatetime(TimeBase):
     dt: Incomplete
-    params: Incomplete
+    params: Parameters
     def __init__(self, dt) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
-    def from_ical(ical, timezone: Incomplete | None = None): ...
+    def from_ical(ical, timezone: str | None = None) -> datetime.datetime: ...
 
 class vDuration(TimeBase):
     td: Incomplete
-    params: Incomplete
+    params: Parameters
     def __init__(self, td) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
     def from_ical(ical): ...
     @property
     def dt(self): ...
 
 class vPeriod(TimeBase):
-    params: Incomplete
+    params: Parameters
     start: Incomplete
     end: Incomplete
     by_duration: Incomplete
     duration: Incomplete
     def __init__(self, per) -> None: ...
     def overlaps(self, other): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
     def from_ical(ical, timezone: Incomplete | None = None): ...
     @property
@@ -140,61 +169,72 @@ class vPeriod(TimeBase):
 class vWeekday(str):
     week_days: Incomplete
     relative: Incomplete
-    params: Incomplete
+    params: Parameters
     def __new__(cls, value, encoding="utf-8"): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical): ...
 
 class vFrequency(str):
     frequencies: Incomplete
-    params: Incomplete
+    params: Parameters
     def __new__(cls, value, encoding="utf-8"): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical): ...
 
+class vMonth(int):
+    leap: bool
+    params: Parameters
+    def __new__(cls, month: vMonth | str | int) -> Self: ...
+    def to_ical(self) -> bytes: ...
+    @classmethod
+    def from_ical(cls, ical: vMonth | str | int) -> Self: ...
+
+class vSkip(vText, Enum):
+    OMIT = "OMIT"
+    FORWARD = "FORWARD"
+    BACKWARD = "BACKWARD"
+
+    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]]
     params: Parameters
     def __init__(self, *args, **kwargs) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def parse_type(cls, key, values): ...
     @classmethod
-    def from_ical(cls, ical) -> dict[str, Incomplete]: ...
-
-class vText(str):
-    encoding: Incomplete
-    params: Incomplete
-    def __new__(cls, value, encoding="utf-8"): ...
-    def to_ical(self): ...
+    @overload
+    def from_ical(cls, ical: _vRecurT) -> _vRecurT: ...
     @classmethod
-    def from_ical(cls, ical): ...
+    @overload
+    def from_ical(cls, ical: str) -> Self: ...
 
 class vTime(TimeBase):
     dt: Incomplete
-    params: Incomplete
+    params: Parameters
     def __init__(self, *args) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
     def from_ical(ical): ...
 
 class vUri(str):
-    params: Incomplete
+    params: Parameters
     def __new__(cls, value, encoding="utf-8"): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical): ...
 
 class vGeo:
     latitude: Incomplete
     longitude: Incomplete
-    params: Incomplete
+    params: Parameters
     def __init__(self, geo) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @staticmethod
     def from_ical(ical): ...
     def __eq__(self, other): ...
@@ -202,17 +242,17 @@ class vGeo:
 class vUTCOffset:
     ignore_exceptions: bool
     td: Incomplete
-    params: Incomplete
+    params: Parameters
     def __init__(self, td) -> None: ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical): ...
     def __eq__(self, other): ...
 
 class vInline(str):
-    params: Incomplete
+    params: Parameters
     def __new__(cls, value, encoding="utf-8"): ...
-    def to_ical(self): ...
+    def to_ical(self) -> bytes: ...
     @classmethod
     def from_ical(cls, ical): ...
 

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

@@ -0,0 +1,8 @@
+from ..timezone.tzp import TZP  # to prevent "tzp" from being defined here
+
+__all__ = ["tzp", "use_pytz", "use_zoneinfo"]
+
+tzp: TZP
+
+def use_pytz() -> None: ...
+def use_zoneinfo() -> None: ...

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

@@ -0,0 +1,29 @@
+__all__ = ["TZProvider"]
+
+import datetime
+from abc import ABC, abstractmethod
+
+from dateutil.rrule import rrule
+
+from ..prop import vRecur
+
+class TZProvider(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+    @abstractmethod
+    def localize_utc(self, dt: datetime.datetime) -> datetime.datetime: ...
+    @abstractmethod
+    def localize(self, dt: datetime.datetime, tz: datetime.tzinfo) -> datetime.datetime: ...
+    @abstractmethod
+    def knows_timezone_id(self, id: str) -> bool: ...
+    @abstractmethod
+    def fix_rrule_until(self, rrule: rrule, ical_rrule: vRecur) -> None: ...
+    @abstractmethod
+    def create_timezone(self, name: str, transition_times, transition_info) -> datetime.tzinfo: ...
+    @abstractmethod
+    def timezone(self, name: str) -> datetime.tzinfo | None: ...
+    @abstractmethod
+    def uses_pytz(self) -> bool: ...
+    @abstractmethod
+    def uses_zoneinfo(self) -> bool: ...

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

@@ -0,0 +1,22 @@
+__all__ = ["PYTZ"]
+
+import datetime
+from typing import Literal
+
+from dateutil.rrule import rrule
+
+from ..cal import Timezone
+from ..prop import vRecur
+from .provider import TZProvider
+
+class PYTZ(TZProvider):
+    @property
+    def name(self) -> Literal["pytz"]: ...
+    def localize_utc(self, dt: datetime.datetime) -> datetime.datetime: ...
+    def localize(self, dt: datetime.datetime, tz: datetime.tzinfo) -> datetime.datetime: ...
+    def knows_timezone_id(self, id: str) -> bool: ...
+    def fix_rrule_until(self, rrule: rrule, ical_rrule: vRecur) -> None: ...
+    def create_timezone(self, tz: Timezone) -> datetime.tzinfo: ...  # type: ignore[override]
+    def timezone(self, name: str) -> datetime.tzinfo | None: ...
+    def uses_pytz(self) -> bool: ...
+    def uses_zoneinfo(self) -> bool: ...

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

@@ -0,0 +1,30 @@
+import datetime
+from typing import Final
+
+from dateutil.rrule import rrule
+
+from ..cal import Timezone
+from ..prop import vRecur
+from .provider import TZProvider
+
+__all__ = ["TZP"]
+
+DEFAULT_TIMEZONE_PROVIDER: Final = "zoneinfo"
+
+class TZP:
+    def __init__(self, provider: str | TZProvider = "zoneinfo") -> None: ...
+    def use_pytz(self) -> None: ...
+    def use_zoneinfo(self) -> None: ...
+    def use(self, provider: str | TZProvider) -> None: ...
+    def use_default(self) -> None: ...
+    def localize_utc(self, dt: datetime.datetime) -> datetime.datetime: ...
+    def localize(self, dt: datetime.datetime, tz: datetime.tzinfo | str) -> datetime.datetime: ...
+    def cache_timezone_component(self, timezone_component: Timezone) -> None: ...
+    def fix_rrule_until(self, rrule: rrule, ical_rrule: vRecur) -> None: ...
+    def create_timezone(self, timezone_component: Timezone) -> datetime.tzinfo: ...
+    def clean_timezone_id(self, tzid: str) -> str: ...
+    def timezone(self, id: str) -> datetime.tzinfo | None: ...
+    def uses_pytz(self) -> bool: ...
+    def uses_zoneinfo(self) -> bool: ...
+    @property
+    def name(self) -> str: ...

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

@@ -0,0 +1,33 @@
+import datetime
+import sys
+from typing import Final, Literal
+
+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
+
+__all__ = ["ZONEINFO"]
+
+class ZONEINFO(TZProvider):
+    @property
+    def name(self) -> Literal["zoneinfo"]: ...
+    utc: Final[ZoneInfo]
+    def localize(self, dt: datetime.datetime, tz: ZoneInfo) -> datetime.datetime: ...  # type: ignore[override]
+    def localize_utc(self, dt: datetime.datetime) -> datetime.datetime: ...
+    def timezone(self, name: str) -> datetime.tzinfo | None: ...
+    def knows_timezone_id(self, id: str) -> bool: ...
+    def fix_rrule_until(self, rrule: rrule, ical_rrule: vRecur) -> None: ...
+    def create_timezone(self, tz: Timezone) -> datetime.tzinfo: ...  # type: ignore[override]
+    def uses_pytz(self) -> Literal[False]: ...
+    def uses_zoneinfo(self) -> Literal[True]: ...
+
+def pickle_tzicalvtz(tzicalvtz): ...
+def pickle_rruleset_with_cache(rs: rruleset): ...
+def unpickle_rruleset_with_cache(rrule, rdate, exrule, exdate, cache): ...

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

@@ -2,6 +2,8 @@ from typing import Final
 
 from .prop import vText
 
+__all__ = ["UIDGenerator"]
+
 class UIDGenerator:
     chars: Final[list[str]]
     @staticmethod

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

@@ -0,0 +1,8 @@
+__all__ = ["__version__", "version", "__version_tuple__", "version_tuple"]
+
+from typing import Final
+
+__version__: Final[str]
+__version_tuple__: Final[tuple[int, ...]]
+version: Final[str]
+version_tuple: Final[tuple[int, ...]]

package/dist/typeshed-fallback/stubs/jwcrypto/METADATA.toml

@@ -0,0 +1,3 @@
+version = "1.5.*"
+upstream_repository = "https://github.com/latchset/jwcrypto"
+requires = ["cryptography"]

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

@@ -0,0 +1,48 @@
+from _typeshed import Incomplete
+from collections.abc import Iterator, MutableMapping
+from typing import Any, NamedTuple
+
+def base64url_encode(payload: str | bytes) -> str: ...
+def base64url_decode(payload: str) -> bytes: ...
+def json_encode(string: str | bytes) -> str: ...
+
+# The function returns json.loads which returns Any
+def json_decode(string: str | bytes) -> Any: ...
+
+class JWException(Exception): ...
+
+class InvalidJWAAlgorithm(JWException):
+    def __init__(self, message: str | None = None) -> None: ...
+
+class InvalidCEKeyLength(JWException):
+    def __init__(self, expected: int, obtained: int) -> None: ...
+
+class InvalidJWEOperation(JWException):
+    def __init__(self, message: str | None = None, exception: BaseException | None = None) -> None: ...
+
+class InvalidJWEKeyType(JWException):
+    def __init__(self, expected: int, obtained: int) -> None: ...
+
+class InvalidJWEKeyLength(JWException):
+    def __init__(self, expected: int, obtained: int) -> None: ...
+
+class InvalidJWSERegOperation(JWException):
+    def __init__(self, message: str | None = None, exception: BaseException | None = None) -> None: ...
+
+class JWKeyNotFound(JWException):
+    def __init__(self, message: str | None = None) -> None: ...
+
+class JWSEHeaderParameter(NamedTuple):
+    description: str
+    mustprotect: bool
+    supported: bool
+    check_fn: Incomplete | None
+
+class JWSEHeaderRegistry(MutableMapping[str, JWSEHeaderParameter]):
+    def __init__(self, init_registry: Incomplete | None = None) -> None: ...
+    def check_header(self, h: str, value) -> bool: ...
+    def __getitem__(self, key: str) -> JWSEHeaderParameter: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __delitem__(self, key: str) -> None: ...
+    def __setitem__(self, h: str, jwse_header_param: JWSEHeaderParameter) -> None: ...
+    def __len__(self) -> int: ...

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

@@ -0,0 +1,35 @@
+from abc import ABCMeta, abstractmethod
+from collections.abc import Mapping
+from typing import ClassVar
+
+default_max_pbkdf2_iterations: int
+
+class JWAAlgorithm(metaclass=ABCMeta):
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+    @property
+    @abstractmethod
+    def description(self) -> str: ...
+    @property
+    @abstractmethod
+    def keysize(self) -> int: ...
+    @property
+    @abstractmethod
+    def algorithm_usage_location(self) -> str: ...
+    @property
+    @abstractmethod
+    def algorithm_use(self) -> str: ...
+    @property
+    def input_keysize(self) -> int: ...
+
+class JWA:
+    algorithms_registry: ClassVar[Mapping[str, JWAAlgorithm]]
+    @classmethod
+    def instantiate_alg(cls, name: str, use: str | None = None) -> JWAAlgorithm: ...
+    @classmethod
+    def signing_alg(cls, name: str) -> JWAAlgorithm: ...
+    @classmethod
+    def keymgmt_alg(cls, name: str) -> JWAAlgorithm: ...
+    @classmethod
+    def encryption_alg(cls, name: str) -> JWAAlgorithm: ...

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

@@ -0,0 +1,51 @@
+from _typeshed import Incomplete
+from collections.abc import Mapping, Sequence
+
+from jwcrypto import common
+from jwcrypto.common import JWException, JWSEHeaderParameter
+from jwcrypto.jwk import JWK, JWKSet
+
+default_max_compressed_size: int
+JWEHeaderRegistry: Mapping[str, JWSEHeaderParameter]
+default_allowed_algs: Sequence[str]
+
+class InvalidJWEData(JWException):
+    def __init__(self, message: str | None = None, exception: BaseException | None = None) -> None: ...
+
+InvalidCEKeyLength = common.InvalidCEKeyLength
+InvalidJWEKeyLength = common.InvalidJWEKeyLength
+InvalidJWEKeyType = common.InvalidJWEKeyType
+InvalidJWEOperation = common.InvalidJWEOperation
+
+class JWE:
+    objects: Incomplete
+    plaintext: Incomplete
+    header_registry: Incomplete
+    cek: Incomplete
+    decryptlog: Incomplete
+    def __init__(
+        self,
+        plaintext: bytes | None = None,
+        protected: str | None = None,
+        unprotected: str | None = None,
+        aad: bytes | None = None,
+        algs: Incomplete | None = None,
+        recipient: str | None = None,
+        header: Incomplete | None = None,
+        header_registry: Incomplete | None = None,
+    ) -> None: ...
+    @property
+    def allowed_algs(self): ...
+    @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 decrypt(self, key: JWK | JWKSet) -> None: ...
+    def deserialize(self, raw_jwe: str | bytes, key: JWK | JWKSet | None = None) -> None: ...
+    @property
+    def payload(self): ...
+    @property
+    def jose_header(self) -> dict[Incomplete, Incomplete]: ...
+    @classmethod
+    def from_jose_token(cls, token: str | bytes) -> JWE: ...
+    def __eq__(self, other: object) -> bool: ...