diff --git a/pyrightconfig.stricter.json b/pyrightconfig.stricter.json index 4e6211a71ed0..aad99df73d48 100644 --- a/pyrightconfig.stricter.json +++ b/pyrightconfig.stricter.json @@ -56,6 +56,7 @@ "stubs/pika", "stubs/psutil", "stubs/psycopg2", + "stubs/pyasn1", "stubs/pyflakes", "stubs/Pygments", "stubs/PyMySQL", diff --git a/stubs/pyasn1/@tests/stubtest_allowlist.txt b/stubs/pyasn1/@tests/stubtest_allowlist.txt new file mode 100644 index 000000000000..93df54d3fbbe --- /dev/null +++ b/stubs/pyasn1/@tests/stubtest_allowlist.txt @@ -0,0 +1,15 @@ +# Unintended re-exports +pyasn1.compat.binary.version_info +pyasn1.compat.octets.version_info +pyasn1.compat.string.version_info + +# type_check_only +pyasn1.type.base.NoValue.plug + +# typeshed typing differences with runtime collections.OrderedDict and builtins.dict +pyasn1.codec.native.encoder.SequenceEncoder.protoDict +pyasn1.codec.native.encoder.SetEncoder.protoDict + +# Attempted "__ne__" operation on ASN.1 schema object +pyasn1.type.base +pyasn1.type.univ diff --git a/stubs/pyasn1/METADATA.toml b/stubs/pyasn1/METADATA.toml new file mode 100644 index 000000000000..de6579f75d05 --- /dev/null +++ b/stubs/pyasn1/METADATA.toml @@ -0,0 +1,4 @@ +version = "0.4.*" + +[tool.stubtest] +ignore_missing_stub = false diff --git a/stubs/pyasn1/pyasn1/__init__.pyi b/stubs/pyasn1/pyasn1/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyasn1/pyasn1/codec/__init__.pyi b/stubs/pyasn1/pyasn1/codec/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyasn1/pyasn1/codec/ber/__init__.pyi b/stubs/pyasn1/pyasn1/codec/ber/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyasn1/pyasn1/codec/ber/decoder.pyi b/stubs/pyasn1/pyasn1/codec/ber/decoder.pyi new file mode 100644 index 000000000000..03afbebd244c --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/ber/decoder.pyi @@ -0,0 +1,337 @@ +from _typeshed import Incomplete +from abc import ABCMeta, abstractmethod +from collections.abc import Callable +from typing_extensions import TypeAlias + +from pyasn1.type import base, char, univ, useful +from pyasn1.type.base import Asn1Type +from pyasn1.type.tag import TagSet + +_Unused: TypeAlias = object + +class AbstractDecoder: + protoComponent: Asn1Type | None + @abstractmethod + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: Incomplete | None = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ) -> None: ... + # Abstract, but implementation is optional + def indefLenValueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: Incomplete | None = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ) -> None: ... + +class AbstractSimpleDecoder(AbstractDecoder, metaclass=ABCMeta): + @staticmethod + def substrateCollector(asn1Object, substrate, length): ... + +class ExplicitTagDecoder(AbstractSimpleDecoder): + protoComponent: univ.Any + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + def indefLenValueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + +class IntegerDecoder(AbstractSimpleDecoder): + protoComponent: univ.Integer + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: _Unused = ..., + substrateFun: _Unused = ..., + **options, + ): ... + +class BooleanDecoder(IntegerDecoder): + protoComponent: univ.Boolean + +class BitStringDecoder(AbstractSimpleDecoder): + protoComponent: univ.BitString + supportConstructedForm: bool + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + def indefLenValueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + +class OctetStringDecoder(AbstractSimpleDecoder): + protoComponent: univ.OctetString + supportConstructedForm: bool + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + def indefLenValueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + +class NullDecoder(AbstractSimpleDecoder): + protoComponent: univ.Null + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: _Unused = ..., + substrateFun: _Unused = ..., + **options, + ): ... + +class ObjectIdentifierDecoder(AbstractSimpleDecoder): + protoComponent: univ.ObjectIdentifier + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: _Unused = ..., + substrateFun: _Unused = ..., + **options, + ): ... + +class RealDecoder(AbstractSimpleDecoder): + protoComponent: univ.Real + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: _Unused = ..., + substrateFun: _Unused = ..., + **options, + ): ... + +class AbstractConstructedDecoder(AbstractDecoder, metaclass=ABCMeta): + protoComponent: base.ConstructedAsn1Type | None + +class UniversalConstructedTypeDecoder(AbstractConstructedDecoder): + protoRecordComponent: univ.SequenceAndSetBase | None + protoSequenceComponent: univ.SequenceOfAndSetOfBase | None + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + def indefLenValueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + +class SequenceOrSequenceOfDecoder(UniversalConstructedTypeDecoder): + protoRecordComponent: univ.Sequence + protoSequenceComponent: univ.SequenceOf + +class SequenceDecoder(SequenceOrSequenceOfDecoder): + protoComponent: univ.Sequence + +class SequenceOfDecoder(SequenceOrSequenceOfDecoder): + protoComponent: univ.SequenceOf + +class SetOrSetOfDecoder(UniversalConstructedTypeDecoder): + protoRecordComponent: univ.Set + protoSequenceComponent: univ.SetOf + +class SetDecoder(SetOrSetOfDecoder): + protoComponent: univ.Set + +class SetOfDecoder(SetOrSetOfDecoder): + protoComponent: univ.SetOf + +class ChoiceDecoder(AbstractConstructedDecoder): + protoComponent: univ.Choice + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: Incomplete | None = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + def indefLenValueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: Incomplete | None = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + +class AnyDecoder(AbstractSimpleDecoder): + protoComponent: univ.Any + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: _Unused = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + def indefLenValueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: Callable[..., Incomplete] | None = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + +class UTF8StringDecoder(OctetStringDecoder): + protoComponent: char.UTF8String + +class NumericStringDecoder(OctetStringDecoder): + protoComponent: char.NumericString + +class PrintableStringDecoder(OctetStringDecoder): + protoComponent: char.PrintableString + +class TeletexStringDecoder(OctetStringDecoder): + protoComponent: char.TeletexString + +class VideotexStringDecoder(OctetStringDecoder): + protoComponent: char.VideotexString + +class IA5StringDecoder(OctetStringDecoder): + protoComponent: char.IA5String + +class GraphicStringDecoder(OctetStringDecoder): + protoComponent: char.GraphicString + +class VisibleStringDecoder(OctetStringDecoder): + protoComponent: char.VisibleString + +class GeneralStringDecoder(OctetStringDecoder): + protoComponent: char.GeneralString + +class UniversalStringDecoder(OctetStringDecoder): + protoComponent: char.UniversalString + +class BMPStringDecoder(OctetStringDecoder): + protoComponent: char.BMPString + +class ObjectDescriptorDecoder(OctetStringDecoder): + protoComponent: useful.ObjectDescriptor + +class GeneralizedTimeDecoder(OctetStringDecoder): + protoComponent: useful.GeneralizedTime + +class UTCTimeDecoder(OctetStringDecoder): + protoComponent: useful.UTCTime + +class Decoder: + defaultErrorState: int + defaultRawDecoder: AnyDecoder + supportIndefLength: bool + def __init__(self, tagMap, typeMap=...) -> None: ... + def __call__( + self, + substrate, + asn1Spec: Asn1Type | None = ..., + tagSet: TagSet | None = ..., + length: int | None = ..., + state=..., + decodeFun: _Unused = ..., + substrateFun: Callable[..., Incomplete] | None = ..., + **options, + ): ... + +decode: Decoder diff --git a/stubs/pyasn1/pyasn1/codec/ber/encoder.pyi b/stubs/pyasn1/pyasn1/codec/ber/encoder.pyi new file mode 100644 index 000000000000..28156078ceb3 --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/ber/encoder.pyi @@ -0,0 +1,67 @@ +from _typeshed import Incomplete +from abc import abstractmethod + +from pyasn1.type.base import Asn1Type + +class AbstractItemEncoder: + supportIndefLenMode: bool + eooIntegerSubstrate: tuple[int, int] + eooOctetsSubstrate: bytes + def encodeTag(self, singleTag, isConstructed): ... + def encodeLength(self, length, defMode): ... + @abstractmethod + def encodeValue(self, value, asn1Spec, encodeFun, **options) -> None: ... + def encode(self, value, asn1Spec: Asn1Type | None = ..., encodeFun: Incomplete | None = ..., **options): ... + +class EndOfOctetsEncoder(AbstractItemEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class BooleanEncoder(AbstractItemEncoder): + supportIndefLenMode: bool + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class IntegerEncoder(AbstractItemEncoder): + supportIndefLenMode: bool + supportCompactZero: bool + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class BitStringEncoder(AbstractItemEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class OctetStringEncoder(AbstractItemEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class NullEncoder(AbstractItemEncoder): + supportIndefLenMode: bool + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class ObjectIdentifierEncoder(AbstractItemEncoder): + supportIndefLenMode: bool + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class RealEncoder(AbstractItemEncoder): + # Mistake in the module, should be False, but is 0 at runtime + supportIndefLenMode: int # type: ignore[assignment] + binEncBase: int + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class SequenceEncoder(AbstractItemEncoder): + omitEmptyOptionals: bool + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class SequenceOfEncoder(AbstractItemEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class ChoiceEncoder(AbstractItemEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class AnyEncoder(OctetStringEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class Encoder: + fixedDefLengthMode: bool | None + fixedChunkSize: int | None + def __init__(self, tagMap, typeMap=...) -> None: ... + def __call__(self, value, asn1Spec: Asn1Type | None = ..., **options): ... + +encode: Encoder diff --git a/stubs/pyasn1/pyasn1/codec/ber/eoo.pyi b/stubs/pyasn1/pyasn1/codec/ber/eoo.pyi new file mode 100644 index 000000000000..b34fb621f382 --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/ber/eoo.pyi @@ -0,0 +1,9 @@ +from pyasn1.type import base +from pyasn1.type.tag import TagSet + +class EndOfOctets(base.SimpleAsn1Type): + defaultValue: int + tagSet: TagSet + def __new__(cls, *args, **kwargs): ... + +endOfOctets: EndOfOctets diff --git a/stubs/pyasn1/pyasn1/codec/cer/__init__.pyi b/stubs/pyasn1/pyasn1/codec/cer/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyasn1/pyasn1/codec/cer/decoder.pyi b/stubs/pyasn1/pyasn1/codec/cer/decoder.pyi new file mode 100644 index 000000000000..fc9640151414 --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/cer/decoder.pyi @@ -0,0 +1,29 @@ +from typing_extensions import TypeAlias + +from pyasn1.codec.ber import decoder +from pyasn1.type import univ +from pyasn1.type.tag import TagSet + +_Unused: TypeAlias = object + +class BooleanDecoder(decoder.AbstractSimpleDecoder): + protoComponent: univ.Boolean + def valueDecoder( + self, + substrate, + asn1Spec, + tagSet: TagSet | None = ..., + length: int | None = ..., + state: _Unused = ..., + decodeFun: _Unused = ..., + substrateFun: _Unused = ..., + **options, + ): ... + +BitStringDecoder = decoder.BitStringDecoder +OctetStringDecoder = decoder.OctetStringDecoder +RealDecoder = decoder.RealDecoder + +class Decoder(decoder.Decoder): ... + +decode: Decoder diff --git a/stubs/pyasn1/pyasn1/codec/cer/encoder.pyi b/stubs/pyasn1/pyasn1/codec/cer/encoder.pyi new file mode 100644 index 000000000000..3b01db7d4e29 --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/cer/encoder.pyi @@ -0,0 +1,40 @@ +from typing import ClassVar + +from pyasn1.codec.ber import encoder + +class BooleanEncoder(encoder.IntegerEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class RealEncoder(encoder.RealEncoder): ... + +class TimeEncoderMixIn: + Z_CHAR: ClassVar[int] + PLUS_CHAR: ClassVar[int] + MINUS_CHAR: ClassVar[int] + COMMA_CHAR: ClassVar[int] + DOT_CHAR: ClassVar[int] + ZERO_CHAR: ClassVar[int] + MIN_LENGTH: ClassVar[int] + MAX_LENGTH: ClassVar[int] + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class GeneralizedTimeEncoder(TimeEncoderMixIn, encoder.OctetStringEncoder): ... +class UTCTimeEncoder(TimeEncoderMixIn, encoder.OctetStringEncoder): ... + +class SetOfEncoder(encoder.SequenceOfEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class SequenceOfEncoder(encoder.SequenceOfEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class SetEncoder(encoder.SequenceEncoder): + def encodeValue(self, value, asn1Spec, encodeFun, **options): ... + +class SequenceEncoder(encoder.SequenceEncoder): + omitEmptyOptionals: bool + +class Encoder(encoder.Encoder): + fixedDefLengthMode: bool + fixedChunkSize: int + +encode: Encoder diff --git a/stubs/pyasn1/pyasn1/codec/der/__init__.pyi b/stubs/pyasn1/pyasn1/codec/der/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyasn1/pyasn1/codec/der/decoder.pyi b/stubs/pyasn1/pyasn1/codec/der/decoder.pyi new file mode 100644 index 000000000000..68aeb5993c48 --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/der/decoder.pyi @@ -0,0 +1,12 @@ +from pyasn1.codec.cer import decoder + +class BitStringDecoder(decoder.BitStringDecoder): + supportConstructedForm: bool + +class OctetStringDecoder(decoder.OctetStringDecoder): + supportConstructedForm: bool + +class Decoder(decoder.Decoder): + supportIndefLength: bool + +decode: Decoder diff --git a/stubs/pyasn1/pyasn1/codec/der/encoder.pyi b/stubs/pyasn1/pyasn1/codec/der/encoder.pyi new file mode 100644 index 000000000000..55c024e6c8f6 --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/der/encoder.pyi @@ -0,0 +1,9 @@ +from pyasn1.codec.cer import encoder + +class SetEncoder(encoder.SetEncoder): ... + +class Encoder(encoder.Encoder): + fixedDefLengthMode: bool + fixedChunkSize: int + +encode: Encoder diff --git a/stubs/pyasn1/pyasn1/codec/native/__init__.pyi b/stubs/pyasn1/pyasn1/codec/native/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyasn1/pyasn1/codec/native/decoder.pyi b/stubs/pyasn1/pyasn1/codec/native/decoder.pyi new file mode 100644 index 000000000000..47296d667536 --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/native/decoder.pyi @@ -0,0 +1,26 @@ +from _typeshed import Incomplete +from collections.abc import Callable +from typing_extensions import TypeAlias + +_Unused: TypeAlias = object + +class AbstractScalarDecoder: + def __call__(self, pyObject, asn1Spec, decodeFun: _Unused = ..., **options): ... + +class BitStringDecoder(AbstractScalarDecoder): + def __call__(self, pyObject, asn1Spec, decodeFun: _Unused = ..., **options): ... + +class SequenceOrSetDecoder: + def __call__(self, pyObject, asn1Spec, decodeFun: Callable[..., Incomplete] | None = ..., **options): ... + +class SequenceOfOrSetOfDecoder: + def __call__(self, pyObject, asn1Spec, decodeFun: Callable[..., Incomplete] | None = ..., **options): ... + +class ChoiceDecoder: + def __call__(self, pyObject, asn1Spec, decodeFun: Callable[..., Incomplete] | None = ..., **options): ... + +class Decoder: + def __init__(self, tagMap, typeMap) -> None: ... + def __call__(self, pyObject, asn1Spec, **options): ... + +decode: Decoder diff --git a/stubs/pyasn1/pyasn1/codec/native/encoder.pyi b/stubs/pyasn1/pyasn1/codec/native/encoder.pyi new file mode 100644 index 000000000000..ec0cb54cfd23 --- /dev/null +++ b/stubs/pyasn1/pyasn1/codec/native/encoder.pyi @@ -0,0 +1,51 @@ +from abc import abstractmethod +from collections import OrderedDict + +class AbstractItemEncoder: + @abstractmethod + def encode(self, value, encodeFun, **options) -> None: ... + +class BooleanEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class IntegerEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class BitStringEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class OctetStringEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class TextStringEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class NullEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options) -> None: ... + +class ObjectIdentifierEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class RealEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class SetEncoder(AbstractItemEncoder): + protoDict = dict + def encode(self, value, encodeFun, **options): ... + +class SequenceEncoder(SetEncoder): + protoDict = OrderedDict + +class SequenceOfEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class ChoiceEncoder(SequenceEncoder): ... + +class AnyEncoder(AbstractItemEncoder): + def encode(self, value, encodeFun, **options): ... + +class Encoder: + def __init__(self, tagMap, typeMap=...) -> None: ... + def __call__(self, value, **options): ... + +encode: Encoder diff --git a/stubs/pyasn1/pyasn1/compat/__init__.pyi b/stubs/pyasn1/pyasn1/compat/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyasn1/pyasn1/compat/binary.pyi b/stubs/pyasn1/pyasn1/compat/binary.pyi new file mode 100644 index 000000000000..d034c5045efb --- /dev/null +++ b/stubs/pyasn1/pyasn1/compat/binary.pyi @@ -0,0 +1 @@ +from builtins import bin as bin diff --git a/stubs/pyasn1/pyasn1/compat/calling.pyi b/stubs/pyasn1/pyasn1/compat/calling.pyi new file mode 100644 index 000000000000..9b1d682f394d --- /dev/null +++ b/stubs/pyasn1/pyasn1/compat/calling.pyi @@ -0,0 +1 @@ +from builtins import callable as callable diff --git a/stubs/pyasn1/pyasn1/compat/dateandtime.pyi b/stubs/pyasn1/pyasn1/compat/dateandtime.pyi new file mode 100644 index 000000000000..739dbe57c9ef --- /dev/null +++ b/stubs/pyasn1/pyasn1/compat/dateandtime.pyi @@ -0,0 +1,3 @@ +from datetime import datetime + +strptime = datetime.strptime diff --git a/stubs/pyasn1/pyasn1/compat/integer.pyi b/stubs/pyasn1/pyasn1/compat/integer.pyi new file mode 100644 index 000000000000..b7cafe63382e --- /dev/null +++ b/stubs/pyasn1/pyasn1/compat/integer.pyi @@ -0,0 +1,8 @@ +from typing_extensions import Literal + +implementation: str +null: Literal[b""] + +def from_bytes(octets, signed: bool = ...): ... +def to_bytes(value, signed: bool = ..., length: int = ...): ... +def bitLength(number): ... diff --git a/stubs/pyasn1/pyasn1/compat/octets.pyi b/stubs/pyasn1/pyasn1/compat/octets.pyi new file mode 100644 index 000000000000..a5ad961dd450 --- /dev/null +++ b/stubs/pyasn1/pyasn1/compat/octets.pyi @@ -0,0 +1,19 @@ +from typing import TypeVar +from typing_extensions import Literal + +_T = TypeVar("_T") + +ints2octs = bytes + +def int2oct(x) -> bytes: ... + +null: Literal[b""] + +def oct2int(x: _T) -> _T: ... +def octs2ints(x: _T) -> _T: ... +def str2octs(x: str) -> bytes: ... +def octs2str(x: bytes) -> str: ... +def isOctetsType(s: object) -> bool: ... +def isStringType(s: object) -> bool: ... + +ensureString = bytes diff --git a/stubs/pyasn1/pyasn1/compat/string.pyi b/stubs/pyasn1/pyasn1/compat/string.pyi new file mode 100644 index 000000000000..c88881c11d78 --- /dev/null +++ b/stubs/pyasn1/pyasn1/compat/string.pyi @@ -0,0 +1,2 @@ +# Same as string.partition(sep) +def partition(string: str, sep: str) -> tuple[str, str, str]: ... diff --git a/stubs/pyasn1/pyasn1/debug.pyi b/stubs/pyasn1/pyasn1/debug.pyi new file mode 100644 index 000000000000..55480cdd527b --- /dev/null +++ b/stubs/pyasn1/pyasn1/debug.pyi @@ -0,0 +1,28 @@ +import logging +from typing import TextIO + +class Printer: + def __init__( + self, + logger: logging.Logger | None = ..., + handler: logging.StreamHandler[TextIO] | None = ..., + formatter: logging.Formatter | None = ..., + ) -> None: ... + def __call__(self, msg) -> None: ... + +NullHandler = logging.NullHandler + +class Debug: + defaultPrinter: Printer + def __init__(self, *flags, **options) -> None: ... + def __call__(self, msg) -> None: ... + def __and__(self, flag): ... + def __rand__(self, flag): ... + +def setLogger(userLogger) -> None: ... +def hexdump(octets): ... + +class Scope: + def __init__(self) -> None: ... + def push(self, token) -> None: ... + def pop(self): ... diff --git a/stubs/pyasn1/pyasn1/error.pyi b/stubs/pyasn1/pyasn1/error.pyi new file mode 100644 index 000000000000..97eb7898d2f2 --- /dev/null +++ b/stubs/pyasn1/pyasn1/error.pyi @@ -0,0 +1,9 @@ +class PyAsn1Error(Exception): ... +class ValueConstraintError(PyAsn1Error): ... +class SubstrateUnderrunError(PyAsn1Error): ... + +class PyAsn1UnicodeError(PyAsn1Error, UnicodeError): + def __init__(self, message, unicode_error: UnicodeError | None = ...) -> None: ... + +class PyAsn1UnicodeDecodeError(PyAsn1UnicodeError, UnicodeDecodeError): ... +class PyAsn1UnicodeEncodeError(PyAsn1UnicodeError, UnicodeEncodeError): ... diff --git a/stubs/pyasn1/pyasn1/type/__init__.pyi b/stubs/pyasn1/pyasn1/type/__init__.pyi new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/stubs/pyasn1/pyasn1/type/base.pyi b/stubs/pyasn1/pyasn1/type/base.pyi new file mode 100644 index 000000000000..455f33c8aff8 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/base.pyi @@ -0,0 +1,149 @@ +from _typeshed import Incomplete +from typing import type_check_only +from typing_extensions import final + +from pyasn1.type import constraint, namedtype +from pyasn1.type.tag import TagSet + +class Asn1Item: + @classmethod + def getTypeId(cls, increment: int = ...): ... + +class Asn1Type(Asn1Item): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + typeId: int | None + def __init__(self, **kwargs) -> None: ... + def __setattr__(self, name, value) -> None: ... + @property + def readOnly(self): ... + @property + def effectiveTagSet(self): ... + @property + def tagMap(self): ... + def isSameTypeWith(self, other, matchTags: bool = ..., matchConstraints: bool = ...): ... + def isSuperTypeOf(self, other, matchTags: bool = ..., matchConstraints: bool = ...): ... + @staticmethod + def isNoValue(*values): ... + def prettyPrint(self, scope: int = ...) -> None: ... + def getTagSet(self): ... + def getEffectiveTagSet(self): ... + def getTagMap(self): ... + def getSubtypeSpec(self): ... + def hasValue(self): ... + +Asn1ItemBase = Asn1Type + +@final +class NoValue: + skipMethods: set[str] + def __new__(cls): ... + def __getattr__(self, attr) -> None: ... + # def __new__..getPlug..plug + @type_check_only + def plug(self, *args: object, **kw: object): ... + # Magic methods assigned dynamically, priority from right to left: plug < str < int < list < dict + __abs__ = int.__abs__ + __add__ = list.__add__ + __and__ = int.__and__ + __bool__ = int.__bool__ + __ceil__ = int.__ceil__ + __class_getitem__ = plug + __contains__ = dict.__contains__ + __delitem__ = dict.__delitem__ + __dir__ = plug + __divmod__ = int.__divmod__ + __float__ = int.__float__ + __floor__ = int.__floor__ + __floordiv__ = int.__floordiv__ + __ge__ = list.__ge__ + __getitem__ = dict.__getitem__ + __gt__ = list.__gt__ + __iadd__ = list.__iadd__ + __imul__ = list.__imul__ + __index__ = int.__index__ + # self instead of cls + __init_subclass__ = plug # pyright: ignore[reportGeneralTypeIssues] + __int__ = int.__int__ + __invert__ = int.__invert__ + __ior__ = plug + __iter__ = dict.__iter__ + __le__ = list.__le__ + __len__ = dict.__len__ + __lshift__ = int.__lshift__ + __lt__ = list.__lt__ + __mod__ = int.__mod__ + __mul__ = list.__mul__ + __neg__ = int.__neg__ + __or__ = int.__or__ + __pos__ = int.__pos__ + __pow__ = int.__pow__ + __radd__ = int.__radd__ + __rand__ = int.__rand__ + __rdivmod__ = int.__rdivmod__ + __reversed__ = list.__reversed__ + __rfloordiv__ = int.__rfloordiv__ + __rlshift__ = int.__rlshift__ + __rmod__ = int.__rmod__ + __rmul__ = list.__rmul__ + __ror__ = int.__ror__ + __round__ = int.__round__ + __rpow__ = int.__rpow__ + __rrshift__ = int.__rrshift__ + __rshift__ = int.__rshift__ + __rsub__ = int.__rsub__ + __rtruediv__ = int.__rtruediv__ + __rxor__ = int.__rxor__ + __setitem__ = list.__setitem__ + __str__ = plug + __sub__ = int.__sub__ + __truediv__ = int.__truediv__ + __trunc__ = int.__trunc__ + __xor__ = int.__xor__ + +class SimpleAsn1Type(Asn1Type): + defaultValue: Incomplete | NoValue + def __init__(self, value=..., **kwargs) -> None: ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __bool__(self) -> bool: ... + def __hash__(self): ... + @property + def isValue(self): ... + def clone(self, value=..., **kwargs): ... + def subtype(self, value=..., **kwargs): ... + def prettyIn(self, value): ... + def prettyOut(self, value): ... + def prettyPrint(self, scope: int = ...): ... + def prettyPrintType(self, scope: int = ...): ... + +AbstractSimpleAsn1Item = SimpleAsn1Type + +class ConstructedAsn1Type(Asn1Type): + strictConstraints: bool + componentType: namedtype.NamedTypes | None + sizeSpec: constraint.ConstraintsIntersection + def __init__(self, **kwargs) -> None: ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __bool__(self) -> bool: ... + @property + def components(self) -> None: ... + def clone(self, **kwargs): ... + def subtype(self, **kwargs): ... + def getComponentByPosition(self, idx) -> None: ... + def setComponentByPosition(self, idx, value, verifyConstraints: bool = ...) -> None: ... + def setComponents(self, *args, **kwargs): ... + def setDefaultComponents(self) -> None: ... + def getComponentType(self): ... + def verifySizeSpec(self) -> None: ... + +AbstractConstructedAsn1Item = ConstructedAsn1Type diff --git a/stubs/pyasn1/pyasn1/type/char.pyi b/stubs/pyasn1/pyasn1/type/char.pyi new file mode 100644 index 000000000000..b61ce2aa8129 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/char.pyi @@ -0,0 +1,72 @@ +from pyasn1.type import univ +from pyasn1.type.tag import TagSet + +class AbstractCharacterString(univ.OctetString): + def __bytes__(self) -> bytes: ... + def prettyIn(self, value): ... + def asOctets(self, padding: bool = ...): ... + def asNumbers(self, padding: bool = ...): ... + def prettyOut(self, value): ... + def prettyPrint(self, scope: int = ...): ... + def __reversed__(self): ... + +class NumericString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class PrintableString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class TeletexString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class T61String(TeletexString): + typeId: int + +class VideotexString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class IA5String(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class GraphicString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class VisibleString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class ISO646String(VisibleString): + typeId: int + +class GeneralString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class UniversalString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class BMPString(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int + +class UTF8String(AbstractCharacterString): + tagSet: TagSet + encoding: str + typeId: int diff --git a/stubs/pyasn1/pyasn1/type/constraint.pyi b/stubs/pyasn1/pyasn1/type/constraint.pyi new file mode 100644 index 000000000000..313ab6f935c0 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/constraint.pyi @@ -0,0 +1,40 @@ +class AbstractConstraint: + def __init__(self, *values) -> None: ... + def __call__(self, value, idx: int | None = ...) -> None: ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __bool__(self) -> bool: ... + def __hash__(self): ... + def getValueMap(self): ... + def isSuperTypeOf(self, otherConstraint): ... + def isSubTypeOf(self, otherConstraint): ... + +class SingleValueConstraint(AbstractConstraint): + def __contains__(self, item) -> bool: ... + def __iter__(self): ... + def __add__(self, constraint): ... + def __sub__(self, constraint): ... + +class ContainedSubtypeConstraint(AbstractConstraint): ... +class ValueRangeConstraint(AbstractConstraint): ... +class ValueSizeConstraint(ValueRangeConstraint): ... +class PermittedAlphabetConstraint(SingleValueConstraint): ... +class ComponentPresentConstraint(AbstractConstraint): ... +class ComponentAbsentConstraint(AbstractConstraint): ... +class WithComponentsConstraint(AbstractConstraint): ... +class InnerTypeConstraint(AbstractConstraint): ... +class ConstraintsExclusion(AbstractConstraint): ... + +class AbstractConstraintSet(AbstractConstraint): + def __getitem__(self, idx): ... + def __iter__(self): ... + def __add__(self, value): ... + def __radd__(self, value): ... + def __len__(self) -> int: ... + +class ConstraintsIntersection(AbstractConstraintSet): ... +class ConstraintsUnion(AbstractConstraintSet): ... diff --git a/stubs/pyasn1/pyasn1/type/error.pyi b/stubs/pyasn1/pyasn1/type/error.pyi new file mode 100644 index 000000000000..b2562205991b --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/error.pyi @@ -0,0 +1,3 @@ +from pyasn1.error import PyAsn1Error + +class ValueConstraintError(PyAsn1Error): ... diff --git a/stubs/pyasn1/pyasn1/type/namedtype.pyi b/stubs/pyasn1/pyasn1/type/namedtype.pyi new file mode 100644 index 000000000000..a70704160551 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/namedtype.pyi @@ -0,0 +1,71 @@ +class NamedType: + isOptional: bool + isDefaulted: bool + def __init__(self, name, asn1Object, openType: type | None = ...) -> None: ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __hash__(self): ... + def __getitem__(self, idx): ... + def __iter__(self): ... + @property + def name(self): ... + @property + def asn1Object(self): ... + @property + def openType(self): ... + def getName(self): ... + def getType(self): ... + +class OptionalNamedType(NamedType): + isOptional: bool + +class DefaultedNamedType(NamedType): + isDefaulted: bool + +class NamedTypes: + def __init__(self, *namedTypes, **kwargs) -> None: ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __hash__(self): ... + def __getitem__(self, idx): ... + def __contains__(self, key) -> bool: ... + def __iter__(self): ... + def __bool__(self) -> bool: ... + def __len__(self) -> int: ... + def values(self): ... + def keys(self): ... + def items(self): ... + def clone(self): ... + + class PostponedError: + def __init__(self, errorMsg) -> None: ... + def __getitem__(self, item) -> None: ... + + def getTypeByPosition(self, idx): ... + def getPositionByType(self, tagSet): ... + def getNameByPosition(self, idx): ... + def getPositionByName(self, name): ... + def getTagMapNearPosition(self, idx): ... + def getPositionNearType(self, tagSet, idx): ... + @property + def minTagSet(self): ... + @property + def tagMap(self): ... + @property + def tagMapUnique(self): ... + @property + def hasOptionalOrDefault(self): ... + @property + def hasOpenTypes(self): ... + @property + def namedTypes(self): ... + @property + def requiredComponents(self): ... diff --git a/stubs/pyasn1/pyasn1/type/namedval.pyi b/stubs/pyasn1/pyasn1/type/namedval.pyi new file mode 100644 index 000000000000..348fb9174417 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/namedval.pyi @@ -0,0 +1,24 @@ +from _typeshed import Incomplete +from collections.abc import Generator + +class NamedValues: + def __init__(self, *args, **kwargs) -> None: ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __hash__(self): ... + def __getitem__(self, key): ... + def __len__(self) -> int: ... + def __contains__(self, key) -> bool: ... + def __iter__(self): ... + def values(self): ... + def keys(self): ... + def items(self) -> Generator[Incomplete, None, None]: ... + def __add__(self, namedValues): ... + def clone(self, *args, **kwargs): ... + def getName(self, value): ... + def getValue(self, name): ... + def getValues(self, *names): ... diff --git a/stubs/pyasn1/pyasn1/type/opentype.pyi b/stubs/pyasn1/pyasn1/type/opentype.pyi new file mode 100644 index 000000000000..e11aeac49136 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/opentype.pyi @@ -0,0 +1,15 @@ +from _typeshed import Incomplete +from collections.abc import Mapping + +from pyasn1.type.base import Asn1Type + +class OpenType: + def __init__(self, name, typeMap: Mapping[Incomplete, Asn1Type] | None = ...) -> None: ... + @property + def name(self): ... + def values(self): ... + def keys(self): ... + def items(self): ... + def __contains__(self, key) -> bool: ... + def __getitem__(self, key): ... + def __iter__(self): ... diff --git a/stubs/pyasn1/pyasn1/type/tag.pyi b/stubs/pyasn1/pyasn1/type/tag.pyi new file mode 100644 index 000000000000..8c484dd60301 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/tag.pyi @@ -0,0 +1,51 @@ +tagClassUniversal: int +tagClassApplication: int +tagClassContext: int +tagClassPrivate: int +tagFormatSimple: int +tagFormatConstructed: int +tagCategoryImplicit: int +tagCategoryExplicit: int +tagCategoryUntagged: int + +class Tag: + def __init__(self, tagClass, tagFormat, tagId) -> None: ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __hash__(self): ... + def __getitem__(self, idx): ... + def __iter__(self): ... + def __and__(self, otherTag): ... + def __or__(self, otherTag): ... + @property + def tagClass(self): ... + @property + def tagFormat(self): ... + @property + def tagId(self): ... + +class TagSet: + def __init__(self, baseTag=..., *superTags) -> None: ... + def __add__(self, superTag): ... + def __radd__(self, superTag): ... + def __getitem__(self, i): ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __hash__(self): ... + def __len__(self) -> int: ... + @property + def baseTag(self): ... + @property + def superTags(self): ... + def tagExplicitly(self, superTag): ... + def tagImplicitly(self, superTag): ... + def isSuperTagSetOf(self, tagSet): ... + def getBaseTag(self): ... diff --git a/stubs/pyasn1/pyasn1/type/tagmap.pyi b/stubs/pyasn1/pyasn1/type/tagmap.pyi new file mode 100644 index 000000000000..196234b755a1 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/tagmap.pyi @@ -0,0 +1,23 @@ +from collections.abc import Container, Mapping + +from pyasn1.type.base import Asn1Type + +class TagMap: + def __init__( + self, + presentTypes: Mapping[TagMap, Asn1Type] | None = ..., + skipTypes: Container[TagMap] | None = ..., + defaultType: Asn1Type | None = ..., + ) -> None: ... + def __contains__(self, tagSet) -> bool: ... + def __getitem__(self, tagSet): ... + def __iter__(self): ... + @property + def presentTypes(self): ... + @property + def skipTypes(self): ... + @property + def defaultType(self): ... + def getPosMap(self): ... + def getNegMap(self): ... + def getDef(self): ... diff --git a/stubs/pyasn1/pyasn1/type/univ.pyi b/stubs/pyasn1/pyasn1/type/univ.pyi new file mode 100644 index 000000000000..c2e3ff45ab1b --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/univ.pyi @@ -0,0 +1,382 @@ +from _typeshed import Incomplete, ReadableBuffer, Self, SupportsRichComparison, SupportsTrunc +from collections.abc import Callable, Generator +from typing import SupportsInt +from typing_extensions import SupportsIndex, TypeAlias + +from pyasn1.type import base, constraint, namedtype, namedval +from pyasn1.type.tag import TagSet + +_SizedIntegerable: TypeAlias = ReadableBuffer | str | SupportsInt | SupportsIndex | SupportsTrunc + +NoValue = base.NoValue +noValue: NoValue + +class Integer(base.SimpleAsn1Type): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + namedValues: namedval.NamedValues + typeId: int + def __init__(self, value=..., **kwargs) -> None: ... + def __and__(self, value): ... + def __rand__(self, value): ... + def __or__(self, value): ... + def __ror__(self, value): ... + def __xor__(self, value): ... + def __rxor__(self, value): ... + def __lshift__(self, value): ... + def __rshift__(self, value): ... + def __add__(self, value): ... + def __radd__(self, value): ... + def __sub__(self, value): ... + def __rsub__(self, value): ... + def __mul__(self, value): ... + def __rmul__(self, value): ... + def __mod__(self, value): ... + def __rmod__(self, value): ... + # Accepts everything builtins.pow does + def __pow__(self: Self, value: complex, modulo: int | None = ...) -> Self: ... + def __rpow__(self, value): ... + def __floordiv__(self, value): ... + def __rfloordiv__(self, value): ... + def __truediv__(self, value): ... + def __rtruediv__(self, value): ... + def __divmod__(self, value): ... + def __rdivmod__(self, value): ... + __hash__ = base.SimpleAsn1Type.__hash__ + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def __abs__(self): ... + def __index__(self) -> int: ... + def __pos__(self): ... + def __neg__(self): ... + def __invert__(self): ... + def __round__(self, n: int = ...): ... + def __floor__(self): ... + def __ceil__(self): ... + def __trunc__(self): ... + def __lt__(self, value): ... + def __le__(self, value): ... + def __eq__(self, value): ... + def __ne__(self, value): ... + def __gt__(self, value): ... + def __ge__(self, value): ... + def prettyIn(self, value): ... + def prettyOut(self, value): ... + def getNamedValues(self): ... + +class Boolean(Integer): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + namedValues: namedval.NamedValues + typeId: int + +SizedIntegerBase = int + +class SizedInteger(SizedIntegerBase): + bitLength: int | None + leadingZeroBits: int | None + def setBitLength(self, bitLength): ... + def __len__(self) -> int: ... + +class BitString(base.SimpleAsn1Type): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + namedValues: namedval.NamedValues + typeId: int + defaultBinValue: str | base.NoValue + defaultHexValue: str | base.NoValue + def __init__(self, value=..., **kwargs) -> None: ... + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __len__(self) -> int: ... + def __getitem__(self, i): ... + def __iter__(self): ... + def __reversed__(self): ... + def __add__(self, value): ... + def __radd__(self, value): ... + def __mul__(self, value): ... + def __rmul__(self, value): ... + def __lshift__(self, count): ... + def __rshift__(self, count): ... + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def asNumbers(self): ... + def asOctets(self): ... + def asInteger(self): ... + def asBinary(self): ... + @classmethod + def fromHexString(cls, value, internalFormat: bool = ..., prepend: _SizedIntegerable | None = ...): ... + @classmethod + def fromBinaryString(cls, value, internalFormat: bool = ..., prepend: _SizedIntegerable | None = ...): ... + @classmethod + def fromOctetString(cls, value, internalFormat: bool = ..., prepend: _SizedIntegerable | None = ..., padding: int = ...): ... + def prettyIn(self, value): ... + +class OctetString(base.SimpleAsn1Type): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + typeId: int + defaultBinValue: str | base.NoValue + defaultHexValue: str | base.NoValue + encoding: str + def __init__(self, value=..., **kwargs) -> None: ... + def prettyIn(self, value): ... + def __bytes__(self) -> bytes: ... + def asOctets(self): ... + def asNumbers(self): ... + def prettyOut(self, value): ... + def prettyPrint(self, scope: int = ...): ... + @staticmethod + def fromBinaryString(value): ... + @staticmethod + def fromHexString(value): ... + def __len__(self) -> int: ... + def __getitem__(self, i): ... + def __iter__(self): ... + def __contains__(self, value) -> bool: ... + def __add__(self, value): ... + def __radd__(self, value): ... + def __mul__(self, value): ... + def __rmul__(self, value): ... + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def __reversed__(self): ... + +class Null(OctetString): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + typeId: int + def prettyIn(self, value): ... + +class ObjectIdentifier(base.SimpleAsn1Type): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + typeId: int + def __add__(self, other): ... + def __radd__(self, other): ... + def asTuple(self): ... + def __len__(self) -> int: ... + def __getitem__(self, i): ... + def __iter__(self): ... + def __contains__(self, value) -> bool: ... + def index(self, suboid): ... + def isPrefixOf(self, other): ... + def prettyIn(self, value): ... + def prettyOut(self, value): ... + +class Real(base.SimpleAsn1Type): + binEncBase: int | None + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + typeId: int + def prettyIn(self, value): ... + def prettyPrint(self, scope: int = ...): ... + @property + def isPlusInf(self): ... + @property + def isMinusInf(self): ... + @property + def isInf(self): ... + def __add__(self, value): ... + def __radd__(self, value): ... + def __mul__(self, value): ... + def __rmul__(self, value): ... + def __sub__(self, value): ... + def __rsub__(self, value): ... + def __mod__(self, value): ... + def __rmod__(self, value): ... + # Accepts everything builtins.pow with a float base does + def __pow__(self: Self, value: complex, modulo: int | None = ...) -> Self: ... + def __rpow__(self, value): ... + def __truediv__(self, value): ... + def __rtruediv__(self, value): ... + def __divmod__(self, value): ... + def __rdivmod__(self, value): ... + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def __abs__(self): ... + def __pos__(self): ... + def __neg__(self): ... + def __round__(self, n: int = ...): ... + def __floor__(self): ... + def __ceil__(self): ... + def __trunc__(self): ... + def __lt__(self, value): ... + def __le__(self, value): ... + def __eq__(self, value): ... + def __ne__(self, value): ... + def __gt__(self, value): ... + def __ge__(self, value): ... + def __bool__(self) -> bool: ... + __hash__ = base.SimpleAsn1Type.__hash__ + def __getitem__(self, idx): ... + def isPlusInfinity(self): ... + def isMinusInfinity(self): ... + def isInfinity(self): ... + +class Enumerated(Integer): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + typeId: int + namedValues: namedval.NamedValues + +class SequenceOfAndSetOfBase(base.ConstructedAsn1Type): + componentType: namedtype.NamedTypes | None + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + def __init__( + self, + *args, + componentType: namedtype.NamedTypes | None = ..., + tagSet: TagSet = ..., + subtypeSpec: constraint.ConstraintsIntersection = ..., + ) -> None: ... + def __getitem__(self, idx): ... + def __setitem__(self, idx, value) -> None: ... + def append(self, value) -> None: ... + def count(self, value): ... + def extend(self, values) -> None: ... + def index(self, value, start: int = ..., stop: int | None = ...): ... + def reverse(self) -> None: ... + def sort(self, key: Callable[[Incomplete], SupportsRichComparison] | None = ..., reverse: bool = ...) -> None: ... + def __len__(self) -> int: ... + def __iter__(self): ... + def getComponentByPosition(self, idx, default=..., instantiate: bool = ...): ... + def setComponentByPosition( + self, idx, value=..., verifyConstraints: bool = ..., matchTags: bool = ..., matchConstraints: bool = ... + ): ... + @property + def componentTagMap(self): ... + @property + def components(self): ... + def clear(self): ... + def reset(self): ... + def prettyPrint(self, scope: int = ...): ... + def prettyPrintType(self, scope: int = ...): ... + @property + def isValue(self): ... + @property + def isInconsistent(self): ... + +class SequenceOf(SequenceOfAndSetOfBase): + typeId: int + +class SetOf(SequenceOfAndSetOfBase): + typeId: int + +class SequenceAndSetBase(base.ConstructedAsn1Type): + componentType: namedtype.NamedTypes + + class DynamicNames: + def __init__(self) -> None: ... + def __len__(self) -> int: ... + def __contains__(self, item) -> bool: ... + def __iter__(self): ... + def __getitem__(self, item): ... + def getNameByPosition(self, idx): ... + def getPositionByName(self, name): ... + def addField(self, idx) -> None: ... + + def __init__(self, **kwargs) -> None: ... + def __getitem__(self, idx): ... + def __setitem__(self, idx, value) -> None: ... + def __contains__(self, key) -> bool: ... + def __len__(self) -> int: ... + def __iter__(self): ... + def values(self) -> Generator[Incomplete, None, None]: ... + def keys(self): ... + def items(self) -> Generator[Incomplete, None, None]: ... + def update(self, *iterValue, **mappingValue) -> None: ... + def clear(self): ... + def reset(self): ... + @property + def components(self): ... + def getComponentByName(self, name, default=..., instantiate: bool = ...): ... + def setComponentByName( + self, name, value=..., verifyConstraints: bool = ..., matchTags: bool = ..., matchConstraints: bool = ... + ): ... + def getComponentByPosition(self, idx, default=..., instantiate: bool = ...): ... + def setComponentByPosition( + self, idx, value=..., verifyConstraints: bool = ..., matchTags: bool = ..., matchConstraints: bool = ... + ): ... + @property + def isValue(self): ... + @property + def isInconsistent(self): ... + def prettyPrint(self, scope: int = ...): ... + def prettyPrintType(self, scope: int = ...): ... + def setDefaultComponents(self): ... + def getComponentType(self): ... + def getNameByPosition(self, idx): ... + +class Sequence(SequenceAndSetBase): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + componentType: namedtype.NamedTypes + typeId: int + def getComponentTagMapNearPosition(self, idx): ... + def getComponentPositionNearType(self, tagSet, idx): ... + +class Set(SequenceAndSetBase): + tagSet: TagSet + componentType: namedtype.NamedTypes + subtypeSpec: constraint.ConstraintsIntersection + typeId: int + def getComponent(self, innerFlag: bool = ...): ... + def getComponentByType(self, tagSet, default=..., instantiate: bool = ..., innerFlag: bool = ...): ... + def setComponentByType( + self, + tagSet, + value=..., + verifyConstraints: bool = ..., + matchTags: bool = ..., + matchConstraints: bool = ..., + innerFlag: bool = ..., + ): ... + @property + def componentTagMap(self): ... + +class Choice(Set): + tagSet: TagSet + componentType: namedtype.NamedTypes + subtypeSpec: constraint.ConstraintsIntersection + typeId: int + def __eq__(self, other): ... + def __ne__(self, other): ... + def __lt__(self, other): ... + def __le__(self, other): ... + def __gt__(self, other): ... + def __ge__(self, other): ... + def __bool__(self) -> bool: ... + def __len__(self) -> int: ... + def __contains__(self, key) -> bool: ... + def __iter__(self): ... + def values(self) -> Generator[Incomplete, None, None]: ... + def keys(self) -> Generator[Incomplete, None, None]: ... + def items(self) -> Generator[Incomplete, None, None]: ... + def checkConsistency(self) -> None: ... + def getComponentByPosition(self, idx, default=..., instantiate: bool = ...): ... + def setComponentByPosition( + self, idx, value=..., verifyConstraints: bool = ..., matchTags: bool = ..., matchConstraints: bool = ... + ): ... + @property + def effectiveTagSet(self): ... + @property + def tagMap(self): ... + def getComponent(self, innerFlag: bool = ...): ... + def getName(self, innerFlag: bool = ...): ... + @property + def isValue(self): ... + def clear(self): ... + def getMinTagSet(self): ... + +class Any(OctetString): + tagSet: TagSet + subtypeSpec: constraint.ConstraintsIntersection + typeId: int + @property + def tagMap(self): ... diff --git a/stubs/pyasn1/pyasn1/type/useful.pyi b/stubs/pyasn1/pyasn1/type/useful.pyi new file mode 100644 index 000000000000..33f13a33a061 --- /dev/null +++ b/stubs/pyasn1/pyasn1/type/useful.pyi @@ -0,0 +1,28 @@ +import datetime + +from pyasn1.type import char +from pyasn1.type.tag import TagSet + +class ObjectDescriptor(char.GraphicString): + tagSet: TagSet + typeId: int + +class TimeMixIn: + class FixedOffset(datetime.tzinfo): + def __init__(self, offset: int = ..., name: str = ...) -> None: ... + def utcoffset(self, dt): ... + def tzname(self, dt): ... + def dst(self, dt): ... + UTC: FixedOffset + @property + def asDateTime(self): ... + @classmethod + def fromDateTime(cls, dt): ... + +class GeneralizedTime(char.VisibleString, TimeMixIn): + tagSet: TagSet + typeId: int + +class UTCTime(char.VisibleString, TimeMixIn): + tagSet: TagSet + typeId: int