raw = file_mmaped(fd)
obj = Something.decode(raw)
-.. warning::
-
- mmap-ed files in Python2.7 does not implement buffer protocol, so
- memoryview won't work on them.
-
.. warning::
mmap maps the **whole** file. So it plays no role if you seek-ed it
:py:meth:`pyderasn.Obj.encode_cer` method, providing the writer where
encoded data will flow::
- opener = io.open if PY2 else open
- with opener("result", "wb") as fd:
+ with open("result", "wb") as fd:
obj.encode_cer(fd.write)
::
::
- opener = io.open if PY2 else open
- with opener("result", "wb") as fd:
+ with open("result", "wb") as fd:
obj.encode2nd(fd.write, iter(state))
.. warning::
from operator import attrgetter
from string import ascii_letters
from string import digits
+from struct import Struct as struct_Struct
from sys import maxsize as sys_maxsize
from sys import version_info
from unicodedata import category as unicat
-from six import add_metaclass
-from six import binary_type
-from six import byte2int
-from six import indexbytes
-from six import int2byte
-from six import integer_types
-from six import iterbytes
-from six import iteritems
-from six import itervalues
-from six import PY2
-from six import string_types
-from six import text_type
-from six import unichr as six_unichr
-from six.moves import xrange as six_xrange
-
-
try:
from termcolor import colored
except ImportError: # pragma: no cover
def colored(what, *args, **kwargs):
return what
-__version__ = "8.4"
+__version__ = "9.0"
__all__ = (
"agg_octet_string",
EOC = b"\x00\x00"
EOC_LEN = len(EOC)
LENINDEF = b"\x80" # length indefinite mark
-LENINDEF_PP_CHAR = "I" if PY2 else "∞"
+LENINDEF_PP_CHAR = "∞"
NAMEDTUPLE_KWARGS = {} if version_info < (3, 6) else {"module": __name__}
SET01 = frozenset("01")
DECIMALS = frozenset(digits)
DECIMAL_SIGNS = ".,"
-NEXT_ATTR_NAME = "next" if PY2 else "__next__"
+NEXT_ATTR_NAME = "__next__"
def file_mmaped(fd):
.. warning::
- It is known to work under neither Python 2.x nor Windows.
+ It does not work under Windows.
"""
import mmap
return memoryview(mmap.mmap(fd.fileno(), length=0, prot=mmap.PROT_READ))
decoding process has passed
:param int offset: binary offset where failure happened
"""
- super(DecodeError, self).__init__()
+ super().__init__()
self.msg = msg
self.klass = klass
self.decode_path = decode_path
class ExceedingData(ASN1Error):
def __init__(self, nbytes):
- super(ExceedingData, self).__init__()
+ super().__init__()
self.nbytes = nbytes
def __str__(self):
class ObjUnknown(ASN1Error):
def __init__(self, name):
- super(ObjUnknown, self).__init__()
+ super().__init__()
self.name = name
def __str__(self):
class ObjNotReady(ASN1Error):
def __init__(self, name):
- super(ObjNotReady, self).__init__()
+ super().__init__()
self.name = name
def __str__(self):
class InvalidValueType(ASN1Error):
def __init__(self, expected_types):
- super(InvalidValueType, self).__init__()
+ super().__init__()
self.expected_types = expected_types
def __str__(self):
class BoundsError(ASN1Error):
def __init__(self, bound_min, value, bound_max):
- super(BoundsError, self).__init__()
+ super().__init__()
self.bound_min = bound_min
self.value = value
self.bound_max = bound_max
return bytes(octets)
+int2byte = struct_Struct(">B").pack
+
+
def tag_encode(num, klass=TagClassUniversal, form=TagFormPrimitive):
"""Encode tag to binary form
It returns tuple with three integers, as
:py:func:`pyderasn.tag_encode` accepts.
"""
- first_octet = byte2int(tag)
+ first_octet = tag[0]
klass = first_octet & 0xC0
form = first_octet & 0x20
if first_octet & 0x1F < 0x1F:
return (klass, form, first_octet & 0x1F)
num = 0
- for octet in iterbytes(tag[1:]):
+ for octet in tag[1:]:
num <<= 7
num |= octet & 0x7F
return (klass, form, num)
"""
if len(data) == 0:
raise NotEnoughData("no data at all")
- if byte2int(data) & 0x1F < 31:
+ if data[0] & 0x1F < 31:
return data[:1], 1, data[1:]
i = 0
while True:
i += 1
if i == len(data):
raise DecodeError("unfinished tag")
- if indexbytes(data, i) & 0x80 == 0:
+ if data[i] & 0x80 == 0:
break
- if i == 1 and indexbytes(data, 1) < 0x1F:
+ if i == 1 and data[1] < 0x1F:
raise DecodeError("unexpected long form")
- if i > 1 and indexbytes(data, 1) & 0x7F == 0:
+ if i > 1 and data[1] & 0x7F == 0:
raise DecodeError("leading zero byte in tag value")
i += 1
return data[:i], i, data[i:]
return int2byte(l)
octets = bytearray(int_bytes_len(l) + 1)
octets[0] = 0x80 | (len(octets) - 1)
- for i in six_xrange(len(octets) - 1, 0, -1):
+ for i in range(len(octets) - 1, 0, -1):
octets[i] = l & 0xFF
l >>= 8
return bytes(octets)
"""
if len(data) == 0:
raise NotEnoughData("no data at all")
- first_octet = byte2int(data)
+ first_octet = data[0]
if first_octet & 0x80 == 0:
return first_octet, 1, data[1:]
octets_num = first_octet & 0x7F
raise NotEnoughData("encoded length is longer than data")
if octets_num == 0:
raise LenIndefForm()
- if byte2int(data[1:]) == 0:
+ if data[1] == 0:
raise DecodeError("leading zeros")
l = 0
- for v in iterbytes(data[1:1 + octets_num]):
+ for v in data[1:1 + octets_num]:
l = (l << 8) | v
if l <= 127:
raise DecodeError("long form instead of short one")
class AutoAddSlots(type):
def __new__(cls, name, bases, _dict):
_dict["__slots__"] = _dict.get("__slots__", ())
- return type.__new__(cls, name, bases, _dict)
+ return super().__new__(cls, name, bases, _dict)
BasicState = namedtuple("BasicState", (
), **NAMEDTUPLE_KWARGS)
-@add_metaclass(AutoAddSlots)
-class Obj(object):
+class Obj(metaclass=AutoAddSlots):
"""Common ASN.1 object class
All ASN.1 types are inherited from it. It has metaclass that
return self.tlen + self.llen + self.vlen
def __str__(self): # pragma: no cover
- return self.__bytes__() if PY2 else self.__unicode__()
+ return self.__unicode__()
def __ne__(self, their):
return not(self == their)
return buf.getvalue()
-class DecodePathDefBy(object):
+class DecodePathDefBy:
"""DEFINED BY representation inside decode path
"""
__slots__ = ("defined_by",)
def colonize_hex(hexed):
"""Separate hexadecimal string with colons
"""
- return ":".join(hexed[i:i + 2] for i in six_xrange(0, len(hexed), 2))
+ return ":".join(hexed[i:i + 2] for i in range(0, len(hexed), 2))
def find_oid_name(asn1_type_name, oid_maps, value):
"(%s)" % colonize_hex(pp.obj.tohex()), "green", with_colours,
))
if with_blob:
- if pp.blob.__class__ == binary_type:
+ if pp.blob.__class__ == bytes:
cols.append(hexenc(pp.blob))
elif pp.blob.__class__ == tuple:
cols.append(", ".join(pp.blob))
decode_path_len = len(pp.decode_path) - decode_path_len_decrease
if decode_path_len > 0:
cols.append(" ." * (decode_path_len + 1))
- if pp.blob.__class__ == binary_type:
+ if pp.blob.__class__ == bytes:
blob = hexenc(pp.blob).upper()
- for i in six_xrange(0, len(blob), 32):
+ for i in range(0, len(blob), 32):
chunk = blob[i:i + 32]
yield " ".join(cols + [colonize_hex(chunk)])
elif pp.blob.__class__ == tuple:
:param default: set default value. Type same as in ``value``
:param bool optional: is object ``OPTIONAL`` in sequence
"""
- super(Boolean, self).__init__(impl, expl, default, optional, _decoded)
+ super().__init__(impl, expl, default, optional, _decoded)
self._value = None if value is None else self._value_sanitize(value)
if default is not None:
default = self._value_sanitize(default)
)
def __setstate__(self, state):
- super(Boolean, self).__setstate__(state)
+ super().__setstate__(state)
self._value = state.value
def __nonzero__(self):
decode_path=decode_path,
offset=offset,
)
- first_octet = byte2int(v)
+ first_octet = v[0]
ber_encoded = False
if first_octet == 0:
value = False
:param default: set default value. Type same as in ``value``
:param bool optional: is object ``OPTIONAL`` in sequence
"""
- super(Integer, self).__init__(impl, expl, default, optional, _decoded)
+ super().__init__(impl, expl, default, optional, _decoded)
self._value = value
specs = getattr(self, "schema", {}) if _specs is None else _specs
self.specs = specs if specs.__class__ == dict else dict(specs)
self._value = default
def _value_sanitize(self, value):
- if isinstance(value, integer_types):
+ if isinstance(value, int):
pass
elif issubclass(value.__class__, Integer):
value = value._value
)
def __setstate__(self, state):
- super(Integer, self).__setstate__(state)
+ super().__setstate__(state)
self.specs = state.specs
self._value = state.value
self._bound_min = state.bound_min
)))
def __eq__(self, their):
- if isinstance(their, integer_types):
+ if isinstance(their, int):
return self._value == their
if not issubclass(their.__class__, Integer):
return False
def named(self):
"""Return named representation (if exists) of the value
"""
- for name, value in iteritems(self.specs):
+ for name, value in self.specs.items():
if value == self._value:
return name
return None
def _encode_payload(self):
self._assert_ready()
value = self._value
- if PY2:
- if value == 0:
- octets = bytearray([0])
- elif value < 0:
- value = -value
- value -= 1
- octets = bytearray()
- while value > 0:
- octets.append((value & 0xFF) ^ 0xFF)
- value >>= 8
- if len(octets) == 0 or octets[-1] & 0x80 == 0:
- octets.append(0xFF)
+ bytes_len = ceil(value.bit_length() / 8) or 1
+ while True:
+ try:
+ octets = value.to_bytes(bytes_len, byteorder="big", signed=True)
+ except OverflowError:
+ bytes_len += 1
else:
- octets = bytearray()
- while value > 0:
- octets.append(value & 0xFF)
- value >>= 8
- if octets[-1] & 0x80 > 0:
- octets.append(0x00)
- octets.reverse()
- octets = bytes(octets)
- else:
- bytes_len = ceil(value.bit_length() / 8) or 1
- while True:
- try:
- octets = value.to_bytes(
- bytes_len,
- byteorder="big",
- signed=True,
- )
- except OverflowError:
- bytes_len += 1
- else:
- break
+ break
return octets
def _encode(self):
offset=offset,
)
v, tail = v[:l], v[l:]
- first_octet = byte2int(v)
+ first_octet = v[0]
if l > 1:
- second_octet = byte2int(v[1:])
+ second_octet = v[1]
if (
((first_octet == 0x00) and (second_octet & 0x80 == 0)) or
((first_octet == 0xFF) and (second_octet & 0x80 != 0))
decode_path=decode_path,
offset=offset,
)
- if PY2:
- value = 0
- if first_octet & 0x80 > 0:
- octets = bytearray()
- for octet in bytearray(v):
- octets.append(octet ^ 0xFF)
- for octet in octets:
- value = (value << 8) | octet
- value += 1
- value = -value
- else:
- for octet in bytearray(v):
- value = (value << 8) | octet
- else:
- value = int.from_bytes(v, byteorder="big", signed=True)
+ value = int.from_bytes(v, byteorder="big", signed=True)
try:
obj = self.__class__(
value=value,
:param default: set default value. Type same as in ``value``
:param bool optional: is object ``OPTIONAL`` in sequence
"""
- super(BitString, self).__init__(impl, expl, default, optional, _decoded)
+ super().__init__(impl, expl, default, optional, _decoded)
specs = getattr(self, "schema", {}) if _specs is None else _specs
self.specs = specs if specs.__class__ == dict else dict(specs)
self._value = None if value is None else self._value_sanitize(value)
bit_len = len(bits)
bits += "0" * ((8 - (bit_len % 8)) % 8)
octets = bytearray(len(bits) // 8)
- for i in six_xrange(len(octets)):
+ for i in range(len(octets)):
octets[i] = int(bits[i * 8:(i * 8) + 8], 2)
return bit_len, bytes(octets)
def _value_sanitize(self, value):
- if isinstance(value, (string_types, binary_type)):
+ if isinstance(value, (str, bytes)):
if (
- isinstance(value, string_types) and
+ isinstance(value, str) and
value.startswith("'")
):
if value.endswith("'B"):
len(value) * 4,
hexdec(value + ("" if len(value) % 2 == 0 else "0")),
)
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
return (len(value) * 8, value)
- raise InvalidValueType((self.__class__, string_types, binary_type))
+ raise InvalidValueType((self.__class__, str, bytes))
if value.__class__ == tuple:
if (
len(value) == 2 and
- isinstance(value[0], integer_types) and
- value[1].__class__ == binary_type
+ isinstance(value[0], int) and
+ value[1].__class__ == bytes
):
return value
bits = []
bits = frozenset(bits)
return self._bits2octets("".join(
("1" if bit in bits else "0")
- for bit in six_xrange(max(bits) + 1)
+ for bit in range(max(bits) + 1)
))
if issubclass(value.__class__, BitString):
return value._value
- raise InvalidValueType((self.__class__, binary_type, string_types))
+ raise InvalidValueType((self.__class__, bytes, str))
@property
def ready(self):
)
def __setstate__(self, state):
- super(BitString, self).__setstate__(state)
+ super().__setstate__(state)
self.specs = state.specs
self._value = state.value
self.tag_constructed = state.tag_constructed
def __iter__(self):
self._assert_ready()
- for i in six_xrange(self._value[0]):
+ for i in range(self._value[0]):
yield self[i]
@property
:returns: [str(name), ...]
"""
- return [name for name, bit in iteritems(self.specs) if self[bit]]
+ return [name for name, bit in self.specs.items() if self[bit]]
def __call__(
self,
bit_len, octets = self._value
if key >= bit_len:
return False
- return (
- byte2int(memoryview(octets)[key // 8:]) >>
- (7 - (key % 8))
- ) & 1 == 1
- if isinstance(key, string_types):
+ return memoryview(octets)[key // 8] >> (7 - (key % 8)) & 1 == 1
+ if isinstance(key, str):
value = self.specs.get(key)
if value is None:
raise ObjUnknown("BitString value: %s" % key)
return
write_full(writer, self.tag_constructed)
write_full(writer, LENINDEF)
- for offset in six_xrange(0, (len(octets) // 999) * 999, 999):
+ for offset in range(0, (len(octets) // 999) * 999, 999):
write_full(writer, b"".join((
BitString.tag_default,
LEN1K,
- int2byte(0),
+ b"\x00",
octets[offset:offset + 999],
)))
tail = octets[offset + 999:]
decode_path=decode_path,
offset=offset,
)
- pad_size = byte2int(v)
+ pad_size = v[0]
if l == 1 and pad_size != 0:
raise DecodeError(
"invalid empty value",
decode_path=decode_path,
offset=offset,
)
- if byte2int(v[l - 1:l]) & ((1 << pad_size) - 1) != 0:
+ if v[l - 1] & ((1 << pad_size) - 1) != 0:
raise DecodeError(
"invalid pad",
klass=self.__class__,
:param default: set default value. Type same as in ``value``
:param bool optional: is object ``OPTIONAL`` in sequence
"""
- super(OctetString, self).__init__(impl, expl, default, optional, _decoded)
+ super().__init__(impl, expl, default, optional, _decoded)
self._value = value
self._bound_min, self._bound_max = getattr(
self,
)
def _value_sanitize(self, value):
- if value.__class__ == binary_type or value.__class__ == memoryview:
+ if value.__class__ == bytes or value.__class__ == memoryview:
pass
elif issubclass(value.__class__, OctetString):
value = value._value
)
def __setstate__(self, state):
- super(OctetString, self).__setstate__(state)
+ super().__setstate__(state)
self._value = state.value
self._bound_min = state.bound_min
self._bound_max = state.bound_max
return bytes(self._value)
def __eq__(self, their):
- if their.__class__ == binary_type:
+ if their.__class__ == bytes:
return self._value == their
if not issubclass(their.__class__, OctetString):
return False
return
write_full(writer, self.tag_constructed)
write_full(writer, LENINDEF)
- for offset in six_xrange(0, (len(octets) // 1000) * 1000, 1000):
+ for offset in range(0, (len(octets) // 1000) * 1000, 1000):
write_full(writer, b"".join((
OctetString.tag_default,
LEN1K,
:param bytes expl: override default tag with ``EXPLICIT`` one
:param bool optional: is object ``OPTIONAL`` in sequence
"""
- super(Null, self).__init__(impl, expl, None, optional, _decoded)
+ super().__init__(impl, expl, None, optional, _decoded)
self.default = None
@property
:param default: set default value. Type same as in ``value``
:param bool optional: is object ``OPTIONAL`` in sequence
"""
- super(ObjectIdentifier, self).__init__(impl, expl, default, optional, _decoded)
+ super().__init__(impl, expl, default, optional, _decoded)
self._value = value
if value is not None:
self._value = self._value_sanitize(value)
def _value_sanitize(self, value):
if issubclass(value.__class__, ObjectIdentifier):
return value._value
- if isinstance(value, string_types):
+ if isinstance(value, str):
try:
value = array("L", (pureint(arc) for arc in value.split(".")))
except ValueError:
)
def __setstate__(self, state):
- super(ObjectIdentifier, self).__setstate__(state)
+ super().__setstate__(state)
self._value = state.value
self.defines = state.defines
i = 0
arc = 0
while True:
- octet = indexbytes(v, i)
+ octet = v[i]
if i == 0 and octet == 0x80:
if ctx.get("bered", False):
ber_encoded = True
_decoded=(0, 0, 0),
bounds=None, # dummy argument, workability for Integer.decode
):
- super(Enumerated, self).__init__(
+ super().__init__(
value, bounds, impl, expl, default, optional, _specs, _decoded,
)
if len(self.specs) == 0:
def _value_sanitize(self, value):
if isinstance(value, self.__class__):
value = value._value
- elif isinstance(value, integer_types):
- for _value in itervalues(self.specs):
+ elif isinstance(value, int):
+ for _value in self.specs.values():
if _value == value:
break
else:
"unknown integer value: %s" % value,
klass=self.__class__,
)
- elif isinstance(value, string_types):
+ elif isinstance(value, str):
value = self.specs.get(value)
if value is None:
raise ObjUnknown("integer value: %s" % value)
value_decoded = None
if isinstance(value, self.__class__):
value_raw = value._value
- elif value.__class__ == text_type:
+ elif value.__class__ == str:
value_decoded = value
- elif value.__class__ == binary_type:
+ elif value.__class__ == bytes:
value_raw = value
else:
- raise InvalidValueType((self.__class__, text_type, binary_type))
+ raise InvalidValueType((self.__class__, str, bytes))
try:
value_raw = (
value_decoded.encode(self.encoding)
return value_raw
def __eq__(self, their):
- if their.__class__ == binary_type:
+ if their.__class__ == bytes:
return self._value == their
- if their.__class__ == text_type:
+ if their.__class__ == str:
return self._value == their.encode(self.encoding)
if not isinstance(their, self.__class__):
return False
def __unicode__(self):
if self.ready:
return self._value.decode(self.encoding)
- return text_type(self._value)
+ return str(self._value)
def __repr__(self):
- return pp_console_row(next(self.pps(no_unicode=PY2)))
+ return pp_console_row(next(self.pps()))
- def pps(self, decode_path=(), no_unicode=False):
+ def pps(self, decode_path=()):
value = None
if self.ready:
- value = (
- hexenc(bytes(self)) if no_unicode else
- "".join(escape_control_unicode(c) for c in self.__unicode__())
- )
+ value = "".join(escape_control_unicode(c) for c in self.__unicode__())
yield _pp(
obj=self,
asn1_type_name=self.asn1_type_name,
asn1_type_name = "UTF8String"
-class AllowableCharsMixin(object):
+class AllowableCharsMixin:
@property
def allowable_chars(self):
- if PY2:
- return self._allowable_chars
- return frozenset(six_unichr(c) for c in self._allowable_chars)
+ return frozenset(chr(c) for c in self._allowable_chars)
def _value_sanitize(self, value):
- value = super(AllowableCharsMixin, self)._value_sanitize(value)
+ value = super()._value_sanitize(value)
if not frozenset(value) <= self._allowable_chars:
raise DecodeError("non satisfying alphabet value")
return value
def __getstate__(self):
return PrintableStringState(
- *super(PrintableString, self).__getstate__(),
+ *super().__getstate__(),
**{"allowable_chars": self._allowable_chars}
)
def __setstate__(self, state):
- super(PrintableString, self).__setstate__(state)
+ super().__setstate__(state)
self._allowable_chars = state.allowable_chars
def __call__(
encoding = "ascii"
asn1_type_name = "IA5"
_allowable_chars = frozenset(b"".join(
- six_unichr(c).encode("ascii") for c in six_xrange(128)
+ chr(c).encode("ascii") for c in range(128)
))
encoding = "ascii"
asn1_type_name = "VisibleString"
_allowable_chars = frozenset(b"".join(
- six_unichr(c).encode("ascii") for c in six_xrange(ord(" "), ord("~") + 1)
+ chr(c).encode("ascii") for c in range(ord(" "), ord("~") + 1)
))
:param default: set default value. Type same as in ``value``
:param bool optional: is object ``OPTIONAL`` in sequence
"""
- super(UTCTime, self).__init__(
- None, None, impl, expl, None, optional, _decoded, ctx,
- )
+ super().__init__(None, None, impl, expl, None, optional, _decoded, ctx)
self._value = value
self.ber_raw = None
if value is not None:
return value.replace(microsecond=0)
def _value_sanitize(self, value, ctx=None):
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
try:
value_decoded = value.decode("ascii")
except (UnicodeEncodeError, UnicodeDecodeError) as err:
if self.ber_encoded:
value += " (%s)" % self.ber_raw
return value
- return text_type(self._pp_value())
+ return str(self._pp_value())
def __getstate__(self):
- return UTCTimeState(
- *super(UTCTime, self).__getstate__(),
- **{"ber_raw": self.ber_raw}
- )
+ return UTCTimeState(*super().__getstate__(), **{"ber_raw": self.ber_raw})
def __setstate__(self, state):
- super(UTCTime, self).__setstate__(state)
+ super().__setstate__(state)
self.ber_raw = state.ber_raw
def __bytes__(self):
return self._encode_time()
def __eq__(self, their):
- if their.__class__ == binary_type:
+ if their.__class__ == bytes:
return self._encode_time() == their
if their.__class__ == datetime:
return self.todatetime() == their
"""
if impl is not None:
raise ValueError("no implicit tag allowed for CHOICE")
- super(Choice, self).__init__(None, expl, default, optional, _decoded)
+ super().__init__(None, expl, default, optional, _decoded)
if schema is None:
schema = getattr(self, "schema", ())
if len(schema) == 0:
)
def __setstate__(self, state):
- super(Choice, self).__setstate__(state)
+ super().__setstate__(state)
self.specs = state.specs
self._value = state.value
@property
def tag_order_cer(self):
- return min(v.tag_order_cer for v in itervalues(self.specs))
+ return min(v.tag_order_cer for v in self.specs.values())
def __getitem__(self, key):
if key not in self.specs:
self._value[1].encode_cer(writer)
def _decode(self, tlv, offset, decode_path, ctx, tag_only, evgen_mode):
- for choice, spec in iteritems(self.specs):
+ for choice, spec in self.specs.items():
sub_decode_path = decode_path + (choice,)
try:
spec.decode(
:param bytes expl: override default tag with ``EXPLICIT`` one
:param bool optional: is object ``OPTIONAL`` in sequence
"""
- super(Any, self).__init__(None, expl, None, optional, _decoded)
+ super().__init__(None, expl, None, optional, _decoded)
if value is None:
self._value = None
else:
value = self._value_sanitize(value)
self._value = value
if self._expl is None:
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
tag_class, _, tag_num = tag_decode(tag_strip(value)[0])
else:
tag_class, tag_num = value.tag_order
self.defined = None
def _value_sanitize(self, value):
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
if len(value) == 0:
raise ValueError("%s value can not be empty" % self.__class__.__name__)
return value
if isinstance(value, self.__class__):
return value._value
if not isinstance(value, Obj):
- raise InvalidValueType((self.__class__, Obj, binary_type))
+ raise InvalidValueType((self.__class__, Obj, bytes))
return value
@property
)
def __setstate__(self, state):
- super(Any, self).__setstate__(state)
+ super().__setstate__(state)
self._value = state.value
self.defined = state.defined
def __eq__(self, their):
- if their.__class__ == binary_type:
- if self._value.__class__ == binary_type:
+ if their.__class__ == bytes:
+ if self._value.__class__ == bytes:
return self._value == their
return self._value.encode() == their
if issubclass(their.__class__, Any):
def __bytes__(self):
self._assert_ready()
value = self._value
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
return value
return self._value.encode()
def _encode(self):
self._assert_ready()
value = self._value
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
return value
return value.encode()
def _encode1st(self, state):
self._assert_ready()
value = self._value
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
return len(value), state
return value.encode1st(state)
def _encode2nd(self, writer, state_iter):
value = self._value
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
write_full(writer, value)
else:
value.encode2nd(writer, state_iter)
def _encode_cer(self, writer):
self._assert_ready()
value = self._value
- if value.__class__ == binary_type:
+ if value.__class__ == bytes:
write_full(writer, value)
else:
value.encode_cer(writer)
value = self._value
if value is None:
pass
- elif value.__class__ == binary_type:
+ elif value.__class__ == bytes:
value = None
else:
value = repr(value)
obj_name=self.__class__.__name__,
decode_path=decode_path,
value=value,
- blob=self._value if self._value.__class__ == binary_type else None,
+ blob=self._value if self._value.__class__ == bytes else None,
optional=self.optional,
default=self == self.default,
impl=None if self.tag == self.tag_default else tag_decode(self.tag),
)
-class SequenceEncode1stMixing(object):
+class SequenceEncode1stMixing:
def _encode1st(self, state):
state.append(0)
idx = len(state) - 1
optional=False,
_decoded=(0, 0, 0),
):
- super(Sequence, self).__init__(impl, expl, default, optional, _decoded)
+ super().__init__(impl, expl, default, optional, _decoded)
if schema is None:
schema = getattr(self, "schema", ())
self.specs = (
@property
def ready(self):
- for name, spec in iteritems(self.specs):
+ for name, spec in self.specs.items():
value = self._value.get(name)
if value is None:
if spec.optional:
def bered(self):
if self.expl_lenindef or self.lenindef or self.ber_encoded:
return True
- return any(value.bered for value in itervalues(self._value))
+ return any(value.bered for value in self._value.values())
def __getstate__(self):
return SequenceState(
self.lenindef,
self.ber_encoded,
self.specs,
- {k: copy(v) for k, v in iteritems(self._value)},
+ {k: copy(v) for k, v in self._value.items()},
)
def __setstate__(self, state):
- super(Sequence, self).__setstate__(state)
+ super().__setstate__(state)
self.specs = state.specs
self._value = state.value
return None
def _values_for_encoding(self):
- for name, spec in iteritems(self.specs):
+ for name, spec in self.specs.items():
value = self._value.get(name)
if value is None:
if spec.optional:
values = {}
ber_encoded = False
ctx_allow_default_values = ctx.get("allow_default_values", False)
- for name, spec in iteritems(self.specs):
+ for name, spec in self.specs.items():
if spec.optional and (
(lenindef and v[:EOC_LEN].tobytes() == EOC) or
len(v) == 0
asn1_type_name = "SET"
def _values_for_encoding(self):
- return sorted(
- super(Set, self)._values_for_encoding(),
- key=attrgetter("tag_order"),
- )
+ return sorted(super()._values_for_encoding(), key=attrgetter("tag_order"))
def _encode_cer(self, writer):
write_full(writer, self.tag + LENINDEF)
for v in sorted(
- super(Set, self)._values_for_encoding(),
+ super()._values_for_encoding(),
key=attrgetter("tag_order_cer"),
):
v.encode_cer(writer)
while len(v) > 0:
if lenindef and v[:EOC_LEN].tobytes() == EOC:
break
- for name, spec in iteritems(_specs_items):
+ for name, spec in _specs_items.items():
sub_decode_path = decode_path + (name,)
try:
spec.decode(
)
tail = v[EOC_LEN:]
obj.lenindef = True
- for name, spec in iteritems(self.specs):
+ for name, spec in self.specs.items():
if name not in values and not spec.optional:
raise DecodeError(
"%s value is not ready" % name,
optional=False,
_decoded=(0, 0, 0),
):
- super(SequenceOf, self).__init__(impl, expl, default, optional, _decoded)
+ super().__init__(impl, expl, default, optional, _decoded)
if schema is None:
schema = getattr(self, "schema", None)
if schema is None:
)
def __setstate__(self, state):
- super(SequenceOf, self).__setstate__(state)
+ super().__setstate__(state)
self.spec = state.spec
self._value = state.value
self._bound_min = state.bound_min
return b"".join((self.tag, len_encode(len(value)), value))
def _encode1st(self, state):
- state = super(SequenceOf, self)._encode1st(state)
+ state = super()._encode1st(state)
if hasattr(self._value, NEXT_ATTR_NAME):
self._value = []
return state
asn1_type_name = "SET OF"
def _value_sanitize(self, value):
- value = super(SetOf, self)._value_sanitize(value)
+ value = super()._value_sanitize(value)
if hasattr(value, NEXT_ATTR_NAME):
raise ValueError(
"SetOf does not support iterator values, as no sense in them"
write_full(writer, EOC)
def _decode(self, tlv, offset, decode_path, ctx, tag_only, evgen_mode):
- return super(SetOf, self)._decode(
+ return super()._decode(
tlv,
offset,
decode_path,
choice = PrimitiveTypes()
choice.specs["SequenceOf"] = SequenceOf(schema=choice)
choice.specs["SetOf"] = SetOf(schema=choice)
- for i in six_xrange(31):
+ for i in range(31):
choice.specs["SequenceOf%d" % i] = SequenceOf(
schema=choice,
expl=tag_ctxc(i),
92 2b 39 20 65 91 e6 8e 95 93 1a 58 df 02 78 ea |.+9 e......X..x.|
^^^^^^^^^^^^^^^^
"""
- return "".join((six_unichr(b) if 0x20 <= b <= 0x7E else ".") for b in ba)
+ return "".join((chr(b) if 0x20 <= b <= 0x7E else ".") for b in ba)
def hexdump(raw):
"""
hexed = hexenc(raw).upper()
addr, cols = 0, ["%08x " % 0]
- for i in six_xrange(0, len(hexed), 2):
+ for i in range(0, len(hexed), 2):
if i != 0 and i // 2 % 8 == 0:
cols[-1] += " "
if i != 0 and i // 2 % 16 == 0:
- cols.append(" |%s|" % ascii_visualize(bytearray(raw[addr:addr + 16])))
+ cols.append(" |%s|" % ascii_visualize(bytes(raw[addr:addr + 16])))
yield cols
addr += 16
cols = ["%08x " % addr]
cols.append(" " + hexed[i:i + 2])
if len(cols) > 0:
- cols.append(" |%s|" % ascii_visualize(bytearray(raw[addr:])))
+ cols.append(" |%s|" % ascii_visualize(bytes(raw[addr:])))
yield cols
def __init__(self, state, *args, **kwargs):
self.state = state
self.scrolled = {"info": False, "hexdump": False}
- super(TW, self).__init__(*args, **kwargs)
+ super().__init__(*args, **kwargs)
def _get_pp(self):
pp = self.get_node().get_value()
line[idx] = (attr, line[idx])
if pp.expl_offset is not None:
- for i in six_xrange(
+ for i in range(
pp.expl_offset,
pp.expl_offset + pp.expl_tlen + pp.expl_llen,
):
attr_set(i, "select-expl")
- for i in six_xrange(pp.offset, pp.offset + pp.tlen + pp.llen + pp.vlen):
+ for i in range(pp.offset, pp.offset + pp.tlen + pp.llen + pp.vlen):
attr_set(i, "select-value")
self.state["hexdump"]._set_body([urwid.Text(line) for line in lines])
self.state["hexdump"].set_focus(pp.offset // 16)
lines.append([
("header", "Hexadecimal: "), colonize_hex(pp.obj.tohex()),
])
- if pp.blob.__class__ == binary_type:
+ if pp.blob.__class__ == bytes:
blob = hexenc(pp.blob).upper()
- for i in six_xrange(0, len(blob), 32):
+ for i in range(0, len(blob), 32):
lines.append([colonize_hex(blob[i:i + 32])])
elif pp.blob.__class__ == tuple:
lines.append([", ".join(pp.blob)])
self.scrolled["info"] = False
self.scrolled["hexdump"] = False
self._state_update()
- return super(TW, self).selectable()
+ return super().selectable()
def _get_display_text_without_offset(self):
pp, constructed = self._get_pp()
("warning", "Saved to: " + dp)
)
return None
- return super(TW, self).keypress(size, key)
+ return super().keypress(size, key)
class PN(urwid.ParentNode):
def __init__(self, state, value, *args, **kwargs):
self.state = state
if not hasattr(value, "_fields"):
value = list(value)
- super(PN, self).__init__(value, *args, **kwargs)
+ super().__init__(value, *args, **kwargs)
def load_widget(self):
return TW(self.state, self)
class LabeledPG(urwid.ProgressBar):
def __init__(self, label, *args, **kwargs):
self.label = label
- super(LabeledPG, self).__init__(*args, **kwargs)
+ super().__init__(*args, **kwargs)
def get_text(self):
- return "%s: %s" % (self.label, super(LabeledPG, self).get_text())
+ return "%s: %s" % (self.label, super().get_text())
WinHexdump = urwid.ListBox([urwid.Text("")])
WinInfo = urwid.ListBox([urwid.Text("")])
from hypothesis.strategies import sets
from hypothesis.strategies import text
from hypothesis.strategies import tuples
-from six import assertRaisesRegex
-from six import binary_type
-from six import byte2int
-from six import indexbytes
-from six import int2byte
-from six import iterbytes
-from six import PY2
-from six import text_type
-from six import unichr as six_unichr
-from six.moves import xrange as six_xrange
-from six.moves.cPickle import dumps as pickle_dumps
-from six.moves.cPickle import HIGHEST_PROTOCOL as pickle_proto
-from six.moves.cPickle import loads as pickle_loads
+from pickle import dumps as pickle_dumps
+from pickle import HIGHEST_PROTOCOL as pickle_proto
+from pickle import loads as pickle_loads
from pyderasn import _pp
from pyderasn import abs_decode_path
def assert_exceeding_data(self, call, junk):
if len(junk) <= 0:
return
- with assertRaisesRegex(self, ExceedingData, "%d trailing bytes" % len(junk)) as err:
+ with self.assertRaisesRegex(ExceedingData, "%d trailing bytes" % len(junk)) as err:
call()
repr(err)
self.assertEqual(tag_decode(raw), (klass, form, num))
self.assertEqual(len(raw), 1)
self.assertEqual(
- byte2int(tag_encode(klass=klass, form=form, num=0)),
- byte2int(raw) & (1 << 7 | 1 << 6 | 1 << 5),
+ tag_encode(klass=klass, form=form, num=0)[0],
+ raw[0] & (1 << 7 | 1 << 6 | 1 << 5),
)
stripped, tlen, tail = tag_strip(memoryview(raw + junk))
self.assertSequenceEqual(stripped.tobytes(), raw)
self.assertEqual(tag_decode(raw), (klass, form, num))
self.assertGreater(len(raw), 1)
self.assertEqual(
- byte2int(tag_encode(klass=klass, form=form, num=0)) | 31,
- byte2int(raw[:1]),
+ tag_encode(klass=klass, form=form, num=0)[0] | 31,
+ raw[0],
)
- self.assertEqual(byte2int(raw[-1:]) & 0x80, 0)
- self.assertTrue(all(b & 0x80 > 0 for b in iterbytes(raw[1:-1])))
+ self.assertEqual(raw[-1] & 0x80, 0)
+ self.assertTrue(all(b & 0x80 > 0 for b in raw[1:-1]))
stripped, tlen, tail = tag_strip(memoryview(raw + junk))
self.assertSequenceEqual(stripped.tobytes(), raw)
self.assertEqual(tlen, len(raw))
raw = bytearray(tag_encode(num=num))
for i in range(1, len(raw)):
raw[i] |= 0x80
- with assertRaisesRegex(self, DecodeError, "unfinished tag"):
+ with self.assertRaisesRegex(DecodeError, "unfinished tag"):
tag_strip(bytes(raw))
def test_go_vectors_valid(self):
integers(min_value=0, max_value=2),
)
def test_long_instead_of_short(self, l, dummy_num):
- octets = (b"\x00" * dummy_num) + int2byte(l)
- octets = int2byte((dummy_num + 1) | 0x80) + octets
+ octets = (b"\x00" * dummy_num) + bytes([l])
+ octets = bytes([(dummy_num + 1) | 0x80]) + octets
with self.assertRaises(DecodeError):
len_decode(octets)
def test_leading_zero_byte(self, klass, form, num):
raw = tag_encode(klass=klass, form=form, num=num)
raw = b"".join((raw[:1], b"\x80", raw[1:]))
- with assertRaisesRegex(self, DecodeError, "leading zero byte"):
+ with self.assertRaisesRegex(DecodeError, "leading zero byte"):
tag_strip(raw)
@given(tag_classes, tag_forms, integers(max_value=30, min_value=0))
def test_unexpected_long_form(self, klass, form, num):
- raw = int2byte(klass | form | 31) + int2byte(num)
- with assertRaisesRegex(self, DecodeError, "unexpected long form"):
+ raw = bytes([klass | form | 31, num])
+ with self.assertRaisesRegex(DecodeError, "unexpected long form"):
tag_strip(raw)
raw = len_encode(l) + junk
decoded, llen, tail = len_decode(memoryview(raw))
self.assertEqual(decoded, l)
- self.assertEqual((llen - 1) | 0x80, byte2int(raw))
+ self.assertEqual((llen - 1) | 0x80, raw[0])
self.assertEqual(llen, len(raw) - len(junk))
- self.assertNotEqual(indexbytes(raw, 1), 0)
+ self.assertNotEqual(raw[1], 0)
self.assertSequenceEqual(tail.tobytes(), junk)
def test_empty(self):
@composite
def text_letters(draw):
result = draw(text(alphabet=ascii_letters, min_size=1))
- if PY2:
- result = result.encode("ascii")
return result
@given(integers(min_value=0 + 1, max_value=255 - 1))
def test_ber_value(self, value):
- with assertRaisesRegex(self, DecodeError, "unacceptable Boolean value"):
+ with self.assertRaisesRegex(DecodeError, "unacceptable Boolean value"):
Boolean().decode(b"".join((
Boolean.tag_default,
len_encode(1),
- int2byte(value),
+ bytes([value]),
)))
- encoded = b"".join((
- Boolean.tag_default,
- len_encode(1),
- int2byte(value),
- ))
+ encoded = b"".join((Boolean.tag_default, len_encode(1), bytes([value])))
obj, _ = Boolean().decode(encoded, ctx={"bered": True})
list(Boolean().decode_evgen(encoded, ctx={"bered": True}))
self.assertTrue(bool(obj))
encoded = expl + LENINDEF + Boolean(False).encode()
with self.assertRaises(LenIndefForm):
Boolean(expl=expl).decode(encoded + junk)
- with assertRaisesRegex(self, DecodeError, "no EOC"):
+ with self.assertRaisesRegex(DecodeError, "no EOC"):
Boolean(expl=expl).decode(encoded + junk, ctx={"bered": True})
obj, tail = Boolean(expl=expl).decode(
encoded + EOC + junk,
with self.assertRaises(BoundsError) as err:
Integer(value=values[0], bounds=(values[1], values[2]))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
Integer(bounds=(values[1], values[2])).decode(
Integer(values[0]).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
Integer(bounds=(values[1], values[2])).decode(
encode2pass(Integer(values[0]))
)
with self.assertRaises(BoundsError) as err:
Integer(value=values[2], bounds=(values[0], values[1]))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
Integer(bounds=(values[0], values[1])).decode(
Integer(values[2]).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
Integer(bounds=(values[0], values[1])).decode(
encode2pass(Integer(values[2]))
)
BitString().decode(b"".join((
BitString.tag_default,
len_encode(1),
- int2byte(pad_size),
+ bytes([pad_size]),
)))
def test_go_vectors_invalid(self):
payload_expected = b""
bit_len_expected = 0
for chunk_input in chunk_inputs:
- if isinstance(chunk_input, binary_type):
+ if isinstance(chunk_input, bytes):
chunks.append(BitString(chunk_input).encode())
payload_expected += chunk_input
bit_len_expected += len(chunk_input) * 8
b"".join(chunks) +
chunk_last.encode()
)
- with assertRaisesRegex(self, DecodeError, "unallowed BER"):
+ with self.assertRaisesRegex(DecodeError, "unallowed BER"):
BitString(impl=tag_encode(impl)).decode(encoded_indefinite)
for lenindef_expected, encoded in (
(True, encoded_indefinite),
decode_path_strat,
)
def test_ber_definite_too_short(self, offset, decode_path):
- with assertRaisesRegex(self, DecodeError, "longer than data") as err:
+ with self.assertRaisesRegex(DecodeError, "longer than data") as err:
BitString().decode(
tag_encode(3, form=TagFormConstructed) + len_encode(1),
offset=offset,
decode_path_strat,
)
def test_ber_definite_no_data(self, offset, decode_path):
- with assertRaisesRegex(self, DecodeError, "zero length") as err:
+ with self.assertRaisesRegex(DecodeError, "zero length") as err:
BitString().decode(
tag_encode(3, form=TagFormConstructed) + len_encode(0),
offset=offset,
def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks):
bs = BitString(b"data").encode()
bs_longer = BitString(b"data-longer").encode()
- with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "chunk out of bounds") as err:
BitString().decode(
(
tag_encode(3, form=TagFormConstructed) +
decode_path_strat,
)
def test_ber_indefinite_no_chunks(self, offset, decode_path):
- with assertRaisesRegex(self, DecodeError, "no chunks") as err:
+ with self.assertRaisesRegex(DecodeError, "no chunks") as err:
BitString().decode(
tag_encode(3, form=TagFormConstructed) + LENINDEF + EOC,
offset=offset,
chunks.append(bs_short)
offset = d.draw(integers(min_value=0))
decode_path = d.draw(decode_path_strat)
- with assertRaisesRegex(self, DecodeError, "multiple of 8 bits") as err:
+ with self.assertRaisesRegex(DecodeError, "multiple of 8 bits") as err:
BitString().decode(
(
tag_encode(3, form=TagFormConstructed) +
def test_invalid_value_type(self):
with self.assertRaises(InvalidValueType) as err:
- OctetString(text_type(123))
+ OctetString(str(123))
repr(err.exception)
@given(booleans())
with self.assertRaises(BoundsError) as err:
OctetString(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
OctetString(bounds=(bound_min, bound_max)).decode(
OctetString(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
OctetString(bounds=(bound_min, bound_max)).decode(
encode2pass(OctetString(value))
)
with self.assertRaises(BoundsError) as err:
OctetString(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
OctetString(bounds=(bound_min, bound_max)).decode(
OctetString(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
OctetString(bounds=(bound_min, bound_max)).decode(
encode2pass(OctetString(value))
)
chunks_len_expected = []
payload_expected = b""
for chunk_input in chunk_inputs:
- if isinstance(chunk_input, binary_type):
+ if isinstance(chunk_input, bytes):
chunks.append(OctetString(chunk_input).encode())
payload_expected += chunk_input
chunks_len_expected.append(len(chunk_input))
len_encode(len(b"".join(chunks))) +
b"".join(chunks)
)
- with assertRaisesRegex(self, DecodeError, "unallowed BER"):
+ with self.assertRaisesRegex(DecodeError, "unallowed BER"):
OctetString(impl=tag_encode(impl)).decode(encoded_indefinite)
for lenindef_expected, encoded in (
(True, encoded_indefinite),
decode_path_strat,
)
def test_ber_definite_too_short(self, offset, decode_path):
- with assertRaisesRegex(self, DecodeError, "longer than data") as err:
+ with self.assertRaisesRegex(DecodeError, "longer than data") as err:
OctetString().decode(
tag_encode(4, form=TagFormConstructed) + len_encode(1),
offset=offset,
def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks):
bs = OctetString(b"data").encode()
bs_longer = OctetString(b"data-longer").encode()
- with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "chunk out of bounds") as err:
OctetString().decode(
(
tag_encode(4, form=TagFormConstructed) +
len_encode(len(data)),
data,
))
- with assertRaisesRegex(self, DecodeError, "unfinished OID"):
+ with self.assertRaisesRegex(DecodeError, "unfinished OID"):
obj.decode(data)
@given(integers(min_value=0))
obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.bered)
- with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
+ with self.assertRaisesRegex(DecodeError, "non normalized arc encoding"):
ObjectIdentifier().decode(tampered)
@given(data_strategy())
obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.bered)
- with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
+ with self.assertRaisesRegex(DecodeError, "non normalized arc encoding"):
ObjectIdentifier().decode(tampered)
base_klass = EWhatever
def test_schema_required(self):
- with assertRaisesRegex(self, ValueError, "schema must be specified"):
+ with self.assertRaisesRegex(ValueError, "schema must be specified"):
Enumerated()
def test_invalid_value_type(self):
repr(err.exception)
def text_alphabet(self):
- return "".join(six_unichr(c) for c in six_xrange(256))
+ return "".join(chr(c) for c in range(256))
@given(booleans())
def test_optional(self, optional):
repr(obj)
list(obj.pps())
pprint(obj, big_blobs=True, with_decode_path=True)
- text_type(obj)
+ str(obj)
with self.assertRaises(ObjNotReady) as err:
obj.encode()
repr(err.exception)
repr(obj)
list(obj.pps())
pprint(obj, big_blobs=True, with_decode_path=True)
- text_type(obj)
+ str(obj)
@given(data_strategy())
def test_comparison(self, d):
self.assertEqual(obj1 == obj2, value1 == value2)
self.assertEqual(obj1 != obj2, value1 != value2)
self.assertEqual(obj1 == bytes(obj2), value1 == value2)
- self.assertEqual(obj1 == text_type(obj2), value1 == value2)
+ self.assertEqual(obj1 == str(obj2), value1 == value2)
obj1 = self.base_klass(value1, impl=tag1)
obj2 = self.base_klass(value1, impl=tag2)
self.assertEqual(obj1 == obj2, tag1 == tag2)
with self.assertRaises(BoundsError) as err:
self.base_klass(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
self.base_klass(bounds=(bound_min, bound_max)).decode(
self.base_klass(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
self.base_klass(bounds=(bound_min, bound_max)).decode(
encode2pass(self.base_klass(value))
)
with self.assertRaises(BoundsError) as err:
self.base_klass(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
self.base_klass(bounds=(bound_min, bound_max)).decode(
self.base_klass(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
self.base_klass(bounds=(bound_min, bound_max)).decode(
encode2pass(self.base_klass(value))
)
self.assertNotEqual(obj_decoded, obj)
self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
self.assertEqual(bytes(obj_decoded), bytes(obj))
- self.assertEqual(text_type(obj_decoded), text_type(obj_expled))
- self.assertEqual(text_type(obj_decoded), text_type(obj))
+ self.assertEqual(str(obj_decoded), str(obj_expled))
+ self.assertEqual(str(obj_decoded), str(obj))
self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
cyrillic_letters = text(
- alphabet="".join(six_unichr(i) for i in list(range(0x0410, 0x044f + 1))),
+ alphabet="".join(chr(i) for i in list(range(0x0410, 0x044f + 1))),
min_size=1,
max_size=5,
)
@given(text(alphabet=ascii_letters, min_size=1, max_size=5))
def test_non_numeric(self, non_numeric_text):
- with assertRaisesRegex(self, DecodeError, "alphabet value"):
+ with self.assertRaisesRegex(DecodeError, "alphabet value"):
self.base_klass(non_numeric_text)
@given(
@given(text(alphabet=sorted(set(whitespace) - set(" ")), min_size=1, max_size=5))
def test_non_printable(self, non_printable_text):
- with assertRaisesRegex(self, DecodeError, "alphabet value"):
+ with self.assertRaisesRegex(DecodeError, "alphabet value"):
self.base_klass(non_printable_text)
@given(
for prop in kwargs.keys():
self.assertFalse(getattr(obj, prop))
s += c
- with assertRaisesRegex(self, DecodeError, "alphabet value"):
+ with self.assertRaisesRegex(DecodeError, "alphabet value"):
self.base_klass(s)
self.base_klass(s, **kwargs)
klass = self.base_klass(**kwargs)
base_klass = IA5String
def text_alphabet(self):
- return "".join(six_unichr(c) for c in six_xrange(128))
+ return "".join(chr(c) for c in range(128))
@given(integers(min_value=128, max_value=255))
def test_alphabet_bad(self, code):
self.assertFalse(obj_encoded.endswith(b"0Z"))
def test_repr_not_ready(self):
- unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime())
+ str(GeneralizedTime())
repr(GeneralizedTime())
def test_x690_vector_valid(self):
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(data_strategy())
def test_valid_ber(self, d):
- min_year = 1901 if PY2 else 2
- year = d.draw(integers(min_value=min_year, max_value=9999))
+ year = d.draw(integers(min_value=2, max_value=9999))
month = d.draw(integers(min_value=1, max_value=12))
day = d.draw(integers(min_value=1, max_value=28))
hours = d.draw(integers(min_value=0, max_value=23))
def test_ns_fractions(self):
GeneralizedTime(b"20010101000000.000001Z")
- with assertRaisesRegex(self, DecodeError, "only microsecond fractions"):
+ with self.assertRaisesRegex(DecodeError, "only microsecond fractions"):
GeneralizedTime(b"20010101000000.0000001Z")
def test_non_pure_integers(self):
GeneralizedTime(data)
def test_aware(self):
- with assertRaisesRegex(self, ValueError, "only naive"):
+ with self.assertRaisesRegex(ValueError, "only naive"):
GeneralizedTime(datetime(2000, 1, 1, 1, tzinfo=UTC))
pass
def test_repr_not_ready(self):
- unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime())
+ str(GeneralizedTime())
repr(UTCTime())
def test_x690_vector_valid(self):
)
def test_aware(self):
- with assertRaisesRegex(self, ValueError, "only naive"):
+ with self.assertRaisesRegex(ValueError, "only naive"):
UTCTime(datetime(2000, 1, 1, 1, tzinfo=UTC))
base_klass = Wahl
def test_schema_required(self):
- with assertRaisesRegex(self, ValueError, "schema must be specified"):
+ with self.assertRaisesRegex(ValueError, "schema must be specified"):
Choice()
def test_impl_forbidden(self):
- with assertRaisesRegex(self, ValueError, "no implicit tag allowed"):
+ with self.assertRaisesRegex(ValueError, "no implicit tag allowed"):
Choice(impl=b"whatever")
def test_invalid_value_type(self):
for (n, v), t in zip(_schema, tags)
]
seq_with_default = SeqWithDefault()
- with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
+ with self.assertRaisesRegex(DecodeError, "DEFAULT value met"):
seq_with_default.decode(seq_encoded)
- with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
+ with self.assertRaisesRegex(DecodeError, "DEFAULT value met"):
list(seq_with_default.decode_evgen(seq_encoded))
for ctx in ({"bered": True}, {"allow_default_values": True}):
seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
len_encode(len(int_encoded + junk)),
int_encoded + junk,
))
- with assertRaisesRegex(self, DecodeError, "remaining"):
+ with self.assertRaisesRegex(DecodeError, "remaining"):
Seq().decode(junked)
@given(sets(text_letters(), min_size=2))
len_encode(len(encoded)),
encoded,
))
- with assertRaisesRegex(self, DecodeError, "unordered SET"):
+ with self.assertRaisesRegex(DecodeError, "unordered SET"):
seq.decode(seq_encoded)
for ctx in ({"bered": True}, {"allow_unordered_set": True}):
seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
repr(err.exception)
def test_schema_required(self):
- with assertRaisesRegex(self, ValueError, "schema must be specified"):
+ with self.assertRaisesRegex(ValueError, "schema must be specified"):
self.base_klass.__mro__[1]()
@given(booleans(), booleans(), binary(min_size=1), binary(min_size=1))
with self.assertRaises(BoundsError) as err:
SeqOf(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
SeqOf(bounds=(bound_min, bound_max)).decode(
SeqOf(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
SeqOf(bounds=(bound_min, bound_max)).decode(
encode2pass(SeqOf(value))
)
with self.assertRaises(BoundsError) as err:
SeqOf(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
SeqOf(bounds=(bound_min, bound_max)).decode(
SeqOf(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
SeqOf(bounds=(bound_min, bound_max)).decode(
encode2pass(SeqOf(value))
)
register_class(SeqOf)
seqof = SeqOf()
pickle_dumps(seqof)
- seqof = seqof(iter(six_xrange(10)))
- with assertRaisesRegex(self, ValueError, "iterator"):
+ seqof = seqof(iter(range(10)))
+ with self.assertRaisesRegex(ValueError, "iterator"):
pickle_dumps(seqof)
def test_iterator_bounds(self):
seqof = None
def gen(n):
- for i in six_xrange(n):
+ for i in range(n):
yield Integer(i)
for n in (9, 21):
seqof = SeqOf(gen(n))
bounds = (1, float("+inf"))
def gen():
- for i in six_xrange(10):
+ for i in range(10):
yield Integer(i)
seqof = SeqOf(gen())
self.assertTrue(seqof.ready)
bounds = (1, float("+inf"))
def gen():
- for i in six_xrange(10):
+ for i in range(10):
yield Integer(i)
seqof = SeqOf(gen())
self.assertTrue(seqof.ready)
class Seq(SetOf):
schema = OctetString()
seq = Seq()
- with assertRaisesRegex(self, DecodeError, "unordered SET OF"):
+ with self.assertRaisesRegex(DecodeError, "unordered SET OF"):
seq.decode(seq_encoded)
for ctx in ({"bered": True}, {"allow_unordered_set": True}):
("oid", oid),
("tgt", OctetString(Integer(123).encode() + b"junk")),
))
- with assertRaisesRegex(self, DecodeError, "remaining data"):
+ with self.assertRaisesRegex(DecodeError, "remaining data"):
Seq().decode(seq.encode())
def test_remaining_data_seqof(self):
("oid", oid),
("tgt", SeqOf([OctetString(Integer(123).encode() + b"junk")])),
))
- with assertRaisesRegex(self, DecodeError, "remaining data"):
+ with self.assertRaisesRegex(DecodeError, "remaining data"):
Seq().decode(seq.encode())
raw = seq.encode()
chosen_choice = "int%d" % chosen
seq.specs[chosen_choice] = seq.specs[chosen_choice](default=123)
- with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
+ with self.assertRaisesRegex(DecodeError, "DEFAULT value met"):
seq.decode(raw)
decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
self.assertTrue(decoded.ber_encoded)
expl = tag_ctxc(123)
raw = Integer(123).encode() + Integer(234).encode()
raw = b"".join((expl, len_encode(len(raw)), raw))
- with assertRaisesRegex(self, DecodeError, "explicit tag out-of-bound"):
+ with self.assertRaisesRegex(DecodeError, "explicit tag out-of-bound"):
Integer(expl=expl).decode(raw)
Integer(expl=expl).decode(raw, ctx={"allow_expl_oob": True})
import pyderasn
version_orig = pyderasn.__version__
pyderasn.__version__ += "different"
- with assertRaisesRegex(self, ValueError, "different PyDERASN version"):
+ with self.assertRaisesRegex(ValueError, "different PyDERASN version"):
pickle_loads(pickled)
pyderasn.__version__ = version_orig
pickle_loads(pickled)