Preferable way is to :ref:`download <download>` tarball with the
signature from `official website <http://www.pyderasn.cypherpunks.ru/>`__::
- $ [fetch|wget] http://www.pyderasn.cypherpunks.ru/download/pyderasn-9.1.tar.zst
- $ [fetch|wget] http://www.pyderasn.cypherpunks.ru/download/pyderasn-9.1.tar.zst.sig
- $ gpg --verify pyderasn-9.1.tar.zst.sig pyderasn-9.1.tar.zst
- $ zstd -d < pyderasn-9.1.tar.zst | tar xf -
- $ cd pyderasn-9.1
+ $ [fetch|wget] http://www.pyderasn.cypherpunks.ru/download/pyderasn-9.2.tar.zst
+ $ [fetch|wget] http://www.pyderasn.cypherpunks.ru/download/pyderasn-9.2.tar.zst.sig
+ $ gpg --verify pyderasn-9.2.tar.zst.sig pyderasn-9.2.tar.zst
+ $ zstd -d < pyderasn-9.2.tar.zst | tar xf -
+ $ cd pyderasn-9.2
$ python setup.py install
# or copy pyderasn.py (possibly termcolor.py) to your PYTHONPATH
You could use pip (**no** OpenPGP authentication is performed!) with PyPI::
- $ echo pyderasn==9.1 --hash=sha256:TO-BE-FILLED > requirements.txt
+ $ echo pyderasn==9.2 --hash=sha256:TO-BE-FILLED > requirements.txt
$ pip install --requirement requirements.txt
You have to verify downloaded tarballs integrity and authenticity to be
* :ref:`bered <bered_ctx>`
* :ref:`defines_by_path <defines_by_path_ctx>`
* :ref:`evgen_mode_upto <evgen_mode_upto_ctx>`
+* :ref:`keep_memoryview <keep_memoryview_ctx>`
.. _pprinting:
page cache used for mmaps. It can take twice the necessary size in
the memory: both in page cache and ZFS ARC.
+.. _keep_memoryview_ctx:
+
+That read-only memoryview could be safe to be used as a value inside
+decoded :py:class:`pyderasn.OctetString` and :py:class:`pyderasn.Any`
+objects. You can enable that by setting `"keep_memoryview": True` in
+:ref:`decode context <ctx>`. No OCTET STRING and ANY values will be
+copied to memory. Of course that works only in DER encoding, where the
+value is continuously encoded.
+
CER encoding
____________
tzUTC = "missing"
-__version__ = "9.1"
+__version__ = "9.2"
__all__ = (
"agg_octet_string",
tag_default = tag_encode(4)
asn1_type_name = "OCTET STRING"
evgen_mode_skip_value = True
+ memoryview_safe = True
def __init__(
self,
self._assert_ready()
return bytes(self._value)
+ def memoryview(self):
+ self._assert_ready()
+ return memoryview(self._value)
+
def __eq__(self, their):
if their.__class__ == bytes:
return self._value == their
decode_path=decode_path,
offset=offset,
)
+ if evgen_mode and self.evgen_mode_skip_value:
+ value = None
+ elif self.memoryview_safe and ctx.get("keep_memoryview", False):
+ value = v
+ else:
+ value = v.tobytes()
try:
obj = self.__class__(
- value=(
- None if (evgen_mode and self.evgen_mode_skip_value)
- else v.tobytes()
- ),
+ value=value,
bounds=(self._bound_min, self._bound_max),
impl=self.tag,
expl=self._expl,
- utf-16-be
"""
__slots__ = ()
+ memoryview_safe = False
def _value_sanitize(self, value):
value_raw = None
return self._value.decode(self.encoding)
return str(self._value)
+ def memoryview(self):
+ raise NotImplementedError()
+
def __repr__(self):
return pp_console_row(next(self.pps()))
value = self._value_sanitize(value)
self._value = value
if self._expl is None:
- if value.__class__ == bytes:
+ if value.__class__ == bytes or value.__class__ == memoryview:
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__ == bytes:
+ if value.__class__ == bytes or value.__class__ == memoryview:
if len(value) == 0:
raise ValueError("%s value can not be empty" % self.__class__.__name__)
return value
self.defined = state.defined
def __eq__(self, their):
- if their.__class__ == bytes:
- if self._value.__class__ == bytes:
+ if their.__class__ == bytes or their.__class__ == memoryview:
+ if self._value.__class__ == bytes or their.__class__ == memoryview:
return self._value == their
return self._value.encode() == their
if issubclass(their.__class__, Any):
if self.ready and their.ready:
- return bytes(self) == bytes(their)
+ return self.memoryview() == their.memoryview()
return self.ready == their.ready
return False
value = self._value
if value.__class__ == bytes:
return value
+ if value.__class__ == memoryview:
+ return bytes(value)
return self._value.encode()
+ def memoryview(self):
+ self._assert_ready()
+ value = self._value
+ if value.__class__ == memoryview:
+ return memoryview(value)
+ return memoryview(bytes(self))
+
@property
def tlen(self):
return 0
def _encode(self):
self._assert_ready()
value = self._value
- if value.__class__ == bytes:
- return value
+ if value.__class__ == bytes or value.__class__ == memoryview:
+ return bytes(self)
return value.encode()
def _encode1st(self, state):
self._assert_ready()
value = self._value
- if value.__class__ == bytes:
+ if value.__class__ == bytes or value.__class__ == memoryview:
return len(value), state
return value.encode1st(state)
def _encode2nd(self, writer, state_iter):
value = self._value
- if value.__class__ == bytes:
+ if value.__class__ == bytes or value.__class__ == memoryview:
write_full(writer, value)
else:
value.encode2nd(writer, state_iter)
def _encode_cer(self, writer):
self._assert_ready()
value = self._value
- if value.__class__ == bytes:
+ if value.__class__ == bytes or value.__class__ == memoryview:
write_full(writer, value)
else:
value.encode_cer(writer)
)
tlvlen = tlen + llen + l
v, tail = tlv[:tlvlen], v[l:]
+ if evgen_mode:
+ value = None
+ elif ctx.get("keep_memoryview", False):
+ value = v
+ else:
+ value = v.tobytes()
obj = self.__class__(
- value=None if evgen_mode else v.tobytes(),
+ value=value,
expl=self._expl,
optional=self.optional,
_decoded=(offset, 0, tlvlen),
value = self._value
if value is None:
pass
- elif value.__class__ == bytes:
+ elif value.__class__ == bytes or value.__class__ == memoryview:
value = None
else:
value = repr(value)
obj_name=self.__class__.__name__,
decode_path=decode_path,
value=value,
- blob=self._value if self._value.__class__ == bytes else None,
+ blob=self._value if (
+ self._value.__class__ == bytes or
+ value.__class__ == memoryview
+ ) else None,
optional=self.optional,
default=self == self.default,
impl=None if self.tag == self.tag_default else tag_decode(self.tag),
integers(min_value=0),
binary(max_size=5),
decode_path_strat,
+ booleans(),
)
- def test_symmetric(self, values, value, tag_expl, offset, tail_junk, decode_path):
+ def test_symmetric(
+ self,
+ values,
+ value,
+ tag_expl,
+ offset,
+ tail_junk,
+ decode_path,
+ keep_memoryview,
+ ):
for klass in (OctetString, OctetStringInherited):
_, _, _, _, default, optional, _decoded = values
obj = klass(
obj_expled.decod(obj_expled_cer, ctx={"bered": True}).encode(),
obj_expled_encoded,
)
+ ctx_dummy["keep_memoryview"] = keep_memoryview
ctx_copied = deepcopy(ctx_dummy)
obj_decoded, tail = obj_expled.decode(
obj_expled_encoded + tail_junk,
self.assertNotEqual(obj_decoded, obj)
self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
self.assertEqual(bytes(obj_decoded), bytes(obj))
+ self.assertIsInstance(
+ obj_decoded._value,
+ memoryview if keep_memoryview else bytes,
+ )
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))
integers(min_value=0),
binary(max_size=5),
decode_path_strat,
+ booleans(),
)
- def test_symmetric(self, values, value, tag_expl, offset, tail_junk, decode_path):
+ def test_symmetric(
+ self,
+ values,
+ value,
+ tag_expl,
+ offset,
+ tail_junk,
+ decode_path,
+ keep_memoryview,
+ ):
for klass in (Any, AnyInherited):
_, _, optional, _decoded = values
obj = klass(value=value, optional=optional, _decoded=_decoded)
list(obj_expled.pps())
pprint(obj_expled, big_blobs=True, with_decode_path=True)
obj_expled_encoded = obj_expled.encode()
+ ctx_dummy["keep_memoryview"] = keep_memoryview
ctx_copied = deepcopy(ctx_dummy)
obj_decoded, tail = obj_expled.decode(
obj_expled_encoded + tail_junk,
self.assertEqual(obj_decoded, obj_expled)
self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
self.assertEqual(bytes(obj_decoded), bytes(obj))
+ self.assertIsInstance(
+ obj_decoded._value,
+ memoryview if keep_memoryview else bytes,
+ )
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))