asnkit-gen-python 1.0.1__tar.gz → 1.2.0__tar.gz

{asnkit_gen_python-1.0.1 → asnkit_gen_python-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asnkit-gen-python
-Version: 1.0.1
+Version: 1.2.0
 Summary: asnkit plugin that makes Python code with data classes from ASN.1
 Author: xadaemon
 Author-email: xadaemon <mxavier@boxtheta.com>
@@ -10,7 +10,7 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Code Generators
-Requires-Dist: asnkitrt==1.0.1
+Requires-Dist: asnkitrt==1.2.0
 Requires-Python: >=3.13
 Project-URL: source, https://github.com/boxtheta/asnkit
 Description-Content-Type: text/x-rst
@@ -19,7 +19,7 @@ asnkit-gen-python
 =================
 
 A plugin for `asnkitcc`_ that generates Python code from ASN.1. The
-generated module imports `asnkitrt`_ and embeds the compiled
+generated module imports `asnkitrt`_ and, by default, embeds the compiled
 specification as bytes. It has a data class for each ``SEQUENCE`` and
 ``SET``, an enumeration for each ``ENUMERATED`` and a class for each
 alternative of a ``CHOICE``, all with methods to encode and decode.
@@ -45,6 +45,16 @@ Options, given with ``--plugin-opt KEY=VALUE``:
 ``codec``
    The codec used when none is given. Default: ``ber``.
 
+``embed``
+   ``false`` to leave the compiled specification out of the module, as
+   for one sent signed or encrypted. The module then has
+   ``use_asni(data, ...)``, which takes the contents of the ``.asni``
+   file with the options of ``asnkitrt.load_asni()`` (``nonce``,
+   ``bound_to``, ``verification_keys``, ``decryption_keys`` and those
+   to accept any), checks it once and uses it for every codec. Until it
+   is called, encoding and decoding raise ``RuntimeError``. The file has
+   to be compiled from the same specification. Default: ``true``.
+
 Names are converted to Python style: ``fooBar`` becomes ``foo_bar`` and
 a type ``Foo-Bar`` becomes ``FooBar``. If two names end up the same in
 Python, generation fails with an error.

{asnkit_gen_python-1.0.1 → asnkit_gen_python-1.2.0}/README.rst

@@ -2,7 +2,7 @@ asnkit-gen-python
 =================
 
 A plugin for `asnkitcc`_ that generates Python code from ASN.1. The
-generated module imports `asnkitrt`_ and embeds the compiled
+generated module imports `asnkitrt`_ and, by default, embeds the compiled
 specification as bytes. It has a data class for each ``SEQUENCE`` and
 ``SET``, an enumeration for each ``ENUMERATED`` and a class for each
 alternative of a ``CHOICE``, all with methods to encode and decode.
@@ -28,6 +28,16 @@ Options, given with ``--plugin-opt KEY=VALUE``:
 ``codec``
    The codec used when none is given. Default: ``ber``.
 
+``embed``
+   ``false`` to leave the compiled specification out of the module, as
+   for one sent signed or encrypted. The module then has
+   ``use_asni(data, ...)``, which takes the contents of the ``.asni``
+   file with the options of ``asnkitrt.load_asni()`` (``nonce``,
+   ``bound_to``, ``verification_keys``, ``decryption_keys`` and those
+   to accept any), checks it once and uses it for every codec. Until it
+   is called, encoding and decoding raise ``RuntimeError``. The file has
+   to be compiled from the same specification. Default: ``true``.
+
 Names are converted to Python style: ``fooBar`` becomes ``foo_bar`` and
 a type ``Foo-Bar`` becomes ``FooBar``. If two names end up the same in
 Python, generation fails with an error.

{asnkit_gen_python-1.0.1 → asnkit_gen_python-1.2.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "asnkit-gen-python"
-version = "1.0.1"
+version = "1.2.0"
 description = "asnkit plugin that makes Python code with data classes from ASN.1"
 readme = "README.rst"
 requires-python = ">=3.13"
-dependencies = ["asnkitrt==1.0.1"]
+dependencies = ["asnkitrt==1.2.0"]
 license = "Apache-2.0"
 license-files = ["LICENSE-COMPILER"]
 classifiers = [

{asnkit_gen_python-1.0.1 → asnkit_gen_python-1.2.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "asnkit-gen-python"
-version = "1.0.1"
+version = "1.2.0"
 description = "asnkit plugin that makes Python code with data classes from ASN.1"
 readme = "README.rst"
 authors = [
@@ -8,7 +8,7 @@ authors = [
 ]
 requires-python = ">=3.13"
 dependencies = [
-    "asnkitrt==1.0.1",
+    "asnkitrt==1.2.0",
 ]
 license = "Apache-2.0"
 license-files = ["LICENSE-COMPILER"]

{asnkit_gen_python-1.0.1 → asnkit_gen_python-1.2.0}/src/asnkit_gen_python/cli.py

@@ -10,9 +10,11 @@
 
 It writes one Python module to the folder. The options are ``name``,
 which is the name of the module without ``.py`` (default: that of
-the first file the specification is from), and ``codec``, which is
+the first file the specification is from), ``codec``, which is
 what the module encodes and decodes with if not told otherwise
-(default: ``ber``).
+(default: ``ber``), and ``embed``, which is ``false`` for a module that
+does not have the compiled specification in it, and is given it with
+its ``use_asni()`` (default: ``true``).
 
 """
 
@@ -26,7 +28,7 @@ from asnkitrt.errors import Error
 from .generate import DEFAULT_CODEC, GenerateError, generate
 from .version import __version__
 
-OPTIONS = {"name", "codec"}
+OPTIONS = {"name", "codec", "embed"}
 
 
 def read_options(items: list[str]) -> dict[str, str]:
@@ -71,7 +73,14 @@ def run(args: argparse.Namespace) -> str:
     if not name.isidentifier():
         raise GenerateError("Expected a name of a module, but got '{}'.".format(name))
 
-    text = generate(asni, sources, options.get("codec", DEFAULT_CODEC))
+    embed = options.get("embed", "true")
+
+    if embed not in ("true", "false"):
+        raise GenerateError(
+            "Expected embed=true or embed=false, but got '{}'.".format(embed)
+        )
+
+    text = generate(asni, sources, options.get("codec", DEFAULT_CODEC), embed == "true")
     os.makedirs(args.out, exist_ok=True)
     path = os.path.join(args.out, name + ".py")
 

{asnkit_gen_python-1.0.1 → asnkit_gen_python-1.2.0}/src/asnkit_gen_python/generate.py

@@ -18,6 +18,10 @@ from typing import Any
 
 from asnkitrt import syntax
 
+# The resolved dictionaries are not part of the API of asnkitrt, which is
+# released with this plugin.
+from asnkitrt.syntax.convert import _compiled_to_dict
+
 DEFAULT_CODEC = "ber"
 
 # What asnkitrt encodes and decodes a type as, by the name of the type.
@@ -69,6 +73,7 @@ TAKEN = {
     "enum",
     "functools",
     "spec",
+    "use_asni",
 }
 
 # Names of what the methods of the classes are called, which a member
@@ -136,17 +141,7 @@ from asnkitrt.runtime import CodecType
 
 DEFAULT_CODEC: CodecType = "{codec}"
 
-# The compiled specification, as the contents of an .asni file.
-_ASNI = (
-{asni}
-)
-
-
-@functools.cache
-def spec(codec: CodecType = DEFAULT_CODEC) -> asnkitrt.Specification:
-    """The specification, loaded for the given codec."""
-
-    return asnkitrt.load_asni(_ASNI, codec)
+{load}
 
 
 def _type(codec: CodecType, asn1_type: tuple[str, str]) -> Any:
@@ -338,6 +333,7 @@ class Generator:
         asni: bytes,
         sources: list[str],
         codec: str,
+        embed: bool = True,
     ) -> None:
         from asnkitrt.version import __version__ as asnkit_version  # noqa: F401
 
@@ -347,11 +343,15 @@ class Generator:
         self.asni = asni
         self.sources = sources
         self.codec = codec
-        self.modules: dict[str, Any] = syntax.compiled_to_dict(compiled)
+        self.embed = embed
+        self.modules: dict[str, Any] = _compiled_to_dict(compiled)
         self.blocks: list[str] = []
         self.registrations: list[str] = []
         self.functions: list[str] = []
         self.exported: list[str] = ["DEFAULT_CODEC", "spec"]
+
+        if not embed:
+            self.exported.append("use_asni")
         self.taken: dict[str, str] = {name: "the code of the module" for name in TAKEN}
         self.names: dict[tuple[str, str], str] = {}
         self.aliases: dict[tuple[str, str], tuple[str, str]] = {}
@@ -728,7 +728,11 @@ class Generator:
             version=self.version,
             sources=", ".join(self.sources) or "a specification",
             codec=self.codec,
-            asni=format_bytes(self.asni),
+            load=(
+                EMBEDDED.format(asni=format_bytes(self.asni))
+                if self.embed
+                else NOT_EMBEDDED
+            ).strip("\n"),
         )
         parts = [
             header,
@@ -745,6 +749,70 @@ class Generator:
         return "\n\n\n".join(part.strip("\n") for part in parts if part.strip()) + "\n"
 
 
+# How a module loads its specification when it is in it.
+EMBEDDED = """\
+# The compiled specification, as the contents of an .asni file.
+_ASNI = (
+{asni}
+)
+
+
+@functools.cache
+def spec(codec: CodecType = DEFAULT_CODEC) -> asnkitrt.Specification:
+    \"\"\"The specification, loaded for the given codec.\"\"\"
+
+    return asnkitrt.load_asni(_ASNI, codec)
+"""
+
+# How a module loads its specification when it is not in it, but given
+# by the code that uses it.
+NOT_EMBEDDED = """\
+# The compiled specification is not in this module: give it with use_asni().
+_SPECIFICATION: asnkitrt.syntax.CompiledSpecification | None = None
+
+
+def use_asni(
+    data: bytes | bytearray,
+    nonce: asnkitrt.syntax.NonceCheck = None,
+    accept_any_nonce: bool = False,
+    bound_to: str | None = None,
+    accept_any_binding: bool = False,
+    verification_keys: asnkitrt.syntax.Keys | None = None,
+    accept_any_signature: bool = False,
+    decryption_keys: asnkitrt.syntax.Keys | None = None,
+) -> None:
+    \"\"\"Uses the contents of an .asni file, made from the specification this
+    module is made from, for all codecs. It is checked once, here, with the
+    options of asnkitrt.load_asni().
+
+    \"\"\"
+
+    global _SPECIFICATION
+
+    _SPECIFICATION = asnkitrt.syntax.from_asni(
+        data,
+        nonce,
+        accept_any_nonce,
+        bound_to,
+        accept_any_binding,
+        verification_keys,
+        accept_any_signature,
+        decryption_keys,
+    )
+    spec.cache_clear()
+
+
+@functools.cache
+def spec(codec: CodecType = DEFAULT_CODEC) -> asnkitrt.Specification:
+    \"\"\"The specification given with use_asni(), loaded for the given codec.\"\"\"
+
+    if _SPECIFICATION is None:
+        raise RuntimeError("No specification: give it with use_asni().")
+
+    return asnkitrt.load(_SPECIFICATION, codec)
+"""
+
+
 REGISTER = """\
 def _register(
     class_: Any, asn1_type: tuple[str, str], shape: Any
@@ -769,13 +837,16 @@ def generate(
     asni: bytes,
     sources: list[str] | None = None,
     codec: str = DEFAULT_CODEC,
+    embed: bool = True,
 ) -> str:
     """Returns the text of a Python module for given contents of an
     ``.asni`` file, which must not be signed, encrypted, bound to
-    something or have a nonce to check, as it is embedded in the module
-    and loaded without any of those. `sources` are the names of the
-    files it was made from, and `codec` is what the module encodes and
-    decodes with if not told otherwise.
+    something or have a nonce to check, as it may be embedded in the
+    module and loaded without any of those. `sources` are the names of
+    the files it was made from, and `codec` is what the module encodes
+    and decodes with if not told otherwise. Without `embed`, the module
+    does not have the specification in it, and is given it with its
+    ``use_asni()``, as from a file that is signed or encrypted.
 
     """
 
@@ -787,4 +858,4 @@ def generate(
             "bound to something or has a nonce, but: {}".format(error)
         )
 
-    return Generator(compiled, asni, sources or [], codec).run()
+    return Generator(compiled, asni, sources or [], codec, embed).run()

{asnkit_gen_python-1.0.1 → asnkit_gen_python-1.2.0}/src/asnkit_gen_python/version.py

@@ -2,4 +2,4 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-__version__ = "1.0.1"
+__version__ = "1.2.0"