asnkit-gen-python 1.0.1__py3-none-any.whl

asnkit_gen_python/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 BoxTheta
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Makes Python code with data classes from a compiled ASN.1
+specification, for `asnkit`.
+
+"""
+
+from .generate import GenerateError, generate
+from .version import __version__
+
+__all__ = ["GenerateError", "generate", "__version__"]

asnkit_gen_python/__main__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2025 BoxTheta
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .cli import main
+
+main()

asnkit_gen_python/cli.py

@@ -0,0 +1,102 @@
+# Copyright (c) 2025 BoxTheta
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""The plugin ``asnkit-gen-python``, as ``asnkitcc generate`` runs it:
+
+.. code-block:: text
+
+   asnkit-gen-python --asni FILE --asnst FILE --out FOLDER [--opt KEY=VALUE ...]
+
+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
+what the module encodes and decodes with if not told otherwise
+(default: ``ber``).
+
+"""
+
+import argparse
+import os
+import sys
+
+from asnkitrt import syntax
+from asnkitrt.errors import Error
+
+from .generate import DEFAULT_CODEC, GenerateError, generate
+from .version import __version__
+
+OPTIONS = {"name", "codec"}
+
+
+def read_options(items: list[str]) -> dict[str, str]:
+    options = {}
+
+    for item in items:
+        key, separator, value = item.partition("=")
+
+        if not separator or key not in OPTIONS:
+            raise GenerateError(
+                "Expected the option {} as KEY=VALUE with a KEY of {}.".format(
+                    item, ", ".join(sorted(OPTIONS))
+                )
+            )
+
+        options[key] = value
+
+    return options
+
+
+def run(args: argparse.Namespace) -> str:
+    options = read_options(args.opt)
+
+    with open(args.asni, "rb") as fin:
+        asni = fin.read()
+
+    # The names of the files it was made from are in the .asnst file.
+    sources: list[str] = []
+
+    if args.asnst is not None:
+        with open(args.asnst, "rb") as fin:
+            header = syntax.read_header(fin.read())
+
+        if header.metadata is not None:
+            sources = [source.name for source in header.metadata.sources if source.name]
+
+    name = options.get("name")
+
+    if name is None:
+        name = os.path.splitext(sources[0])[0] if sources else "specification"
+
+    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))
+    os.makedirs(args.out, exist_ok=True)
+    path = os.path.join(args.out, name + ".py")
+
+    with open(path, "w", encoding="utf-8") as fout:
+        fout.write(text)
+
+    return path
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="asnkit-gen-python",
+        description="Makes Python code with data classes from a compiled ASN.1 "
+        "specification. Run by `asnkitcc generate`.",
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument("--asni", required=True, help="The compiled specification.")
+    parser.add_argument("--asnst", help="The syntax tree of the specification.")
+    parser.add_argument("--out", required=True, help="The folder to write to.")
+    parser.add_argument(
+        "--opt", action="append", default=[], help="An option, as KEY=VALUE."
+    )
+    args = parser.parse_args()
+
+    try:
+        run(args)
+    except (GenerateError, Error, OSError) as error:
+        sys.exit("error: {}".format(error))

asnkit_gen_python/generate.py

@@ -0,0 +1,790 @@
+# Copyright (c) 2025 BoxTheta
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Makes the text of a Python module from a compiled ASN.1 specification.
+
+The module imports asnkit, has the ``.asni`` file in it as bytes and has
+a data class for each SEQUENCE and SET, an enumeration for each
+ENUMERATED and a class for each alternative of a CHOICE, with methods
+to encode and decode them and to turn them into and from what asnkitrt
+encodes and decodes.
+
+"""
+
+import keyword
+import re
+from typing import Any
+
+from asnkitrt import syntax
+
+DEFAULT_CODEC = "ber"
+
+# What asnkitrt encodes and decodes a type as, by the name of the type.
+# Everything else is a SEQUENCE, a SET, a SEQUENCE OF, a SET OF, a CHOICE,
+# an ENUMERATED or the name of a type.
+PLAIN_TYPES = {
+    "BOOLEAN": "bool",
+    "INTEGER": "int",
+    "REAL": "float",
+    "OCTET STRING": "bytes",
+    "BIT STRING": "tuple[bytes, int]",
+    "NULL": "None",
+    "OBJECT IDENTIFIER": "str",
+    "RELATIVE-OID": "str",
+    "ObjectDescriptor": "str",
+    "TeletexString": "str",
+    "VideotexString": "str",
+    "NumericString": "str",
+    "PrintableString": "str",
+    "IA5String": "str",
+    "VisibleString": "str",
+    "GeneralString": "str",
+    "UTF8String": "str",
+    "BMPString": "str",
+    "GraphicString": "str",
+    "UniversalString": "str",
+    "UTCTime": "datetime.datetime",
+    "GeneralizedTime": "datetime.datetime",
+    "DATE-TIME": "datetime.datetime",
+    "DATE": "datetime.date",
+    "TIME-OF-DAY": "datetime.time",
+    "DURATION": "str",
+    "ANY": "Any",
+    "ANY DEFINED BY": "Any",
+    "OpenType": "Any",
+    "EXTERNAL": "Any",
+}
+
+# What the generated code uses, which a type is not called.
+TAKEN = {
+    "Any",
+    "ClassVar",
+    "CodecType",
+    "DEFAULT_CODEC",
+    "TypeAlias",
+    "asnkit",
+    "dataclasses",
+    "datetime",
+    "enum",
+    "functools",
+    "spec",
+}
+
+# Names of what the methods of the classes are called, which a member
+# can not be called.
+RESERVED = {"encode", "decode", "to_value", "from_value"}
+
+
+class GenerateError(Exception):
+    pass
+
+
+def camel(name: str) -> str:
+    """``foo-bar`` and ``foo_bar`` are ``FooBar``."""
+
+    parts = [part for part in re.split(r"[-_]", name) if part]
+    result = "".join(part[0].upper() + part[1:] for part in parts)
+
+    if not result or result[0].isdigit():
+        result = "T" + result
+
+    return result
+
+
+def snake(name: str) -> str:
+    """``fooBar`` and ``foo-bar`` are ``foo_bar``."""
+
+    name = name.replace("-", "_")
+    name = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", name)
+    name = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+    name = name.lower()
+
+    if not name or name[0].isdigit():
+        name = "n" + name
+
+    return name
+
+
+def field_name(name: str) -> str:
+    result = snake(name)
+
+    if keyword.iskeyword(result) or result in RESERVED or result.startswith("_"):
+        result += "_"
+
+    return result
+
+
+HEADER = '''\
+# Generated by asnkit-gen-python {version} from {sources}. Do not edit.
+#
+# This file is made from the specification it names, and needs the asnkitrt
+# package (MIT) to run. It may be used under terms of your choice: the code
+# that asnkit-gen-python copies into it is not under the Apache License of
+# the plugin.
+
+from __future__ import annotations
+
+import dataclasses
+import datetime
+import enum
+import functools
+from typing import Any, ClassVar, TypeAlias
+
+import asnkitrt
+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)
+
+
+def _type(codec: CodecType, asn1_type: tuple[str, str]) -> Any:
+    if not asn1_type[1]:
+        raise TypeError(
+            "This type is a part of another type, and is not encoded on its own."
+        )
+
+    return spec(codec).modules[asn1_type[0]][asn1_type[1]]
+
+
+def _to_value(shape: Any, obj: Any) -> Any:
+    """What asnkitrt encodes, for an object of given shape."""
+
+    if shape is None:
+        return obj
+
+    if isinstance(shape, type):
+        shape = getattr(shape, "_shape")
+
+    kind = shape[0]
+
+    if kind == "seq":
+        values: dict[str, Any] = {{}}
+
+        for attribute, name, member_shape, how in shape[2]:
+            member = getattr(obj, attribute)
+
+            if how == "null":
+                # An optional NULL is there if it is True.
+                if member:
+                    values[name] = None
+            elif how == "required_null":
+                values[name] = None
+            elif member is not None:
+                values[name] = _to_value(member_shape, member)
+
+        return values
+
+    if kind == "list":
+        return [_to_value(shape[1], item) for item in obj]
+
+    if kind == "choice":
+        return (obj._alternative, _to_value(shape[1][obj._alternative][1], obj.value))
+
+    if kind == "enum":
+        return obj.value if isinstance(obj, enum.Enum) else obj
+
+    raise TypeError(shape)
+
+
+def _from_value(shape: Any, value: Any) -> Any:
+    """The object of given shape for what asnkitrt decoded."""
+
+    if shape is None:
+        return value
+
+    if isinstance(shape, type):
+        shape = getattr(shape, "_shape")
+
+    kind = shape[0]
+
+    if kind == "seq":
+        arguments: dict[str, Any] = {{}}
+
+        for attribute, name, member_shape, how in shape[2]:
+            if how == "null":
+                arguments[attribute] = name in value
+            elif name in value:
+                arguments[attribute] = _from_value(member_shape, value[name])
+            elif how == "required_null":
+                arguments[attribute] = None
+
+        return shape[1](**arguments)
+
+    if kind == "list":
+        return [_from_value(shape[1], item) for item in value]
+
+    if kind == "choice":
+        alternative, shape_of_value = shape[1][value[0]]
+
+        return alternative(_from_value(shape_of_value, value[1]))
+
+    if kind == "enum":
+        # An extensible enumeration is None for what it does not know of.
+        if value is None:
+            return None
+
+        try:
+            return shape[1](value)
+        except ValueError:
+            return value
+
+    raise TypeError(shape)
+
+
+def _alternatives(table: dict[str, Any]) -> dict[str, Any]:
+    # The alternatives of a choice, which are not of one type.
+    return table
+
+
+def _encode(
+    asn1_type: tuple[str, str],
+    shape: Any,
+    obj: Any,
+    codec: CodecType,
+    check_types: bool,
+    check_constraints: bool,
+) -> bytes:
+    type_ = _type(codec, asn1_type)
+    value = _to_value(shape, obj)
+
+    if check_types:
+        type_.check_types(value)
+
+    if check_constraints:
+        type_.check_constraints(value)
+
+    return bytes(type_.encode(value))
+
+
+def _decode(
+    asn1_type: tuple[str, str],
+    shape: Any,
+    data: bytes | bytearray,
+    codec: CodecType,
+    check_constraints: bool,
+) -> Any:
+    type_ = _type(codec, asn1_type)
+    value = type_.decode(data)
+
+    if check_constraints:
+        type_.check_constraints(value)
+
+    return _from_value(shape, value)
+
+
+class _Methods:
+    """What the classes made from ASN.1 types can do."""
+
+    _asn1_type: ClassVar[tuple[str, str]]
+    _shape: ClassVar[Any]
+
+    def to_value(self) -> Any:
+        """What asnkitrt encodes for this object."""
+
+        return _to_value(type(self)._shape, self)
+
+    @classmethod
+    def from_value(cls, value: Any) -> Any:
+        """The object for what asnkitrt decoded."""
+
+        return _from_value(cls._shape, value)
+
+    def encode(
+        self,
+        codec: CodecType = DEFAULT_CODEC,
+        check_types: bool = True,
+        check_constraints: bool = False,
+    ) -> bytes:
+        """This object encoded with given codec."""
+
+        return _encode(
+            type(self)._asn1_type,
+            type(self)._shape,
+            self,
+            codec,
+            check_types,
+            check_constraints,
+        )
+
+    @classmethod
+    def decode(
+        cls,
+        data: bytes | bytearray,
+        codec: CodecType = DEFAULT_CODEC,
+        check_constraints: bool = False,
+    ) -> Any:
+        """The object that given data is when decoded with given codec."""
+
+        return _decode(cls._asn1_type, cls._shape, data, codec, check_constraints)
+'''
+
+
+class Generator:
+    def __init__(
+        self,
+        compiled: syntax.CompiledSpecification,
+        asni: bytes,
+        sources: list[str],
+        codec: str,
+    ) -> None:
+        from asnkitrt.version import __version__ as asnkit_version  # noqa: F401
+
+        from .version import __version__
+
+        self.version = __version__
+        self.asni = asni
+        self.sources = sources
+        self.codec = codec
+        self.modules: dict[str, Any] = syntax.compiled_to_dict(compiled)
+        self.blocks: list[str] = []
+        self.registrations: list[str] = []
+        self.functions: list[str] = []
+        self.exported: list[str] = ["DEFAULT_CODEC", "spec"]
+        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]] = {}
+        self.alias_blocks: list[str] = []
+
+    # Names.
+
+    def take(self, name: str, what: str) -> str:
+        if name in self.taken:
+            raise GenerateError(
+                "Both {} and {} are called {} in Python.".format(
+                    self.taken[name], what, name
+                )
+            )
+
+        self.taken[name] = what
+
+        return name
+
+    def name_the_types(self) -> None:
+        count: dict[str, int] = {}
+
+        for module in self.modules.values():
+            for type_name in module["types"]:
+                count[camel(type_name)] = count.get(camel(type_name), 0) + 1
+
+        for module_name, module in self.modules.items():
+            for type_name in module["types"]:
+                name = camel(type_name)
+
+                if count[name] > 1:
+                    # The same name in more than one module.
+                    name = camel(module_name) + name
+
+                if name in TAKEN:
+                    name += "_"
+
+                self.names[(module_name, type_name)] = self.take(
+                    name, "the type {} of {}".format(type_name, module_name)
+                )
+
+    # Types.
+
+    def lookup(self, module_name: str, type_name: str) -> Any:
+        try:
+            return self.modules[module_name]["types"][type_name]
+        except KeyError:
+            raise GenerateError(
+                "The type {} of {} is not in the specification.".format(
+                    type_name, module_name
+                )
+            )
+
+    def kind_of(self, descriptor: dict[str, Any]) -> str:
+        type_name = descriptor["type"]
+
+        if type_name in ("SEQUENCE", "SET"):
+            return "sequence"
+
+        if type_name == "CHOICE":
+            return "choice"
+
+        if type_name == "ENUMERATED":
+            return "enumerated"
+
+        return "other"
+
+    def resolves_to_null(self, descriptor: dict[str, Any], module_name: str) -> bool:
+        seen = set()
+
+        while True:
+            type_name = descriptor["type"]
+            module_name = descriptor.get("module-name", module_name)
+
+            if type_name == "NULL":
+                return True
+
+            if (
+                type_name in PLAIN_TYPES
+                or type_name in ("SEQUENCE", "SET", "CHOICE", "ENUMERATED")
+                or type_name.endswith(" OF")
+                or "&" in type_name
+                or (module_name, type_name) in seen
+                or type_name not in self.modules.get(module_name, {}).get("types", {})
+            ):
+                return False
+
+            seen.add((module_name, type_name))
+            descriptor = self.lookup(module_name, type_name)
+
+    def annotate(
+        self, descriptor: dict[str, Any], module_name: str, context: str
+    ) -> tuple[str, str]:
+        """Returns the Python type of given type and its shape, and makes
+        the classes it needs, named after the context if it has no name.
+
+        """
+
+        type_name = descriptor["type"]
+        module_name = descriptor.get("module-name", module_name)
+
+        if type_name in PLAIN_TYPES:
+            return PLAIN_TYPES[type_name], "None"
+
+        if "&" in type_name:
+            # A field of an object class.
+            return "Any", "None"
+
+        if type_name in ("SEQUENCE", "SET"):
+            name = self.take(camel(context), "the type in " + context)
+            self.sequence(name, descriptor, module_name, None)
+
+            return name, name
+
+        if type_name == "CHOICE":
+            name = self.take(camel(context), "the type in " + context)
+            self.choice(name, descriptor, module_name, None)
+
+            return name, name
+
+        if type_name == "ENUMERATED":
+            name = self.take(camel(context), "the type in " + context)
+            self.enumerated(name, descriptor, module_name, None)
+
+            return name, name
+
+        if type_name in ("SEQUENCE OF", "SET OF"):
+            element, shape = self.annotate(
+                descriptor["element"], module_name, context + "-element"
+            )
+
+            return "list[{}]".format(element), '("list", {})'.format(shape)
+
+        # The name of a type.
+        key = (module_name, type_name)
+        target = self.lookup(module_name, type_name)
+
+        if self.kind_of(target) != "other":
+            return self.names[key], self.names[key]
+
+        return self.names[key], self.alias(key, target)[1]
+
+    def alias(
+        self, key: tuple[str, str], descriptor: dict[str, Any]
+    ) -> tuple[str, str]:
+        """The Python type and the shape of a type that is not a class of
+        its own, which is made once.
+
+        """
+
+        if key not in self.aliases:
+            # Not recursive, as only a class can refer to itself.
+            self.aliases[key] = self.annotate(descriptor, key[0], self.names[key])
+
+        return self.aliases[key]
+
+    # Classes.
+
+    def register(self, name: str, module_name: str, type_name: str, shape: str) -> None:
+        self.registrations.append(
+            "_register({}, ({!r}, {!r}), {})".format(
+                name, module_name, type_name, shape
+            )
+        )
+
+    def members(self, descriptor: dict[str, Any]) -> list[tuple[dict[str, Any], bool]]:
+        """The members, with whether each is in an extension."""
+
+        members: list[tuple[dict[str, Any], bool]] = []
+        in_extension = False
+
+        for member in descriptor["members"]:
+            if member is None:
+                in_extension = not in_extension
+            elif isinstance(member, list):
+                members.extend((item, True) for item in member)
+            else:
+                members.append((member, in_extension))
+
+        return members
+
+    def sequence(
+        self,
+        name: str,
+        descriptor: dict[str, Any],
+        module_name: str,
+        type_name: str | None,
+    ) -> None:
+        lines = [
+            "@dataclasses.dataclass(kw_only=True)",
+            "class {}(_Methods):".format(name),
+        ]
+        fields = []
+        attributes: dict[str, str] = {}
+
+        scope = descriptor.get("module-name", module_name)
+
+        for member, in_extension in self.members(descriptor):
+            asn1_name = member["name"]
+            attribute = field_name(asn1_name)
+
+            if attribute in attributes:
+                raise GenerateError(
+                    "Both {} and {} of {} are called {} in Python.".format(
+                        attributes[attribute], asn1_name, name, attribute
+                    )
+                )
+
+            attributes[attribute] = asn1_name
+            annotation, shape = self.annotate(member, scope, name + "-" + asn1_name)
+            optional = in_extension or member.get("optional") or "default" in member
+            null = self.resolves_to_null(member, scope)
+
+            if optional and null:
+                lines.append("    {}: bool = False".format(attribute))
+                how = "null"
+            elif null:
+                lines.append("    {}: None = None".format(attribute))
+                how = "required_null"
+            elif optional:
+                lines.append("    {}: {} | None = None".format(attribute, annotation))
+                how = "optional"
+            else:
+                lines.append("    {}: {}".format(attribute, annotation))
+                how = "required"
+
+            fields.append(
+                "({!r}, {!r}, {}, {!r})".format(attribute, asn1_name, shape, how)
+            )
+
+        if not attributes:
+            lines.append("    pass")
+
+        self.blocks.append("\n".join(lines))
+        self.exported.append(name)
+        shape = '("seq", {}, ({}))'.format(name, "".join(f + ", " for f in fields))
+        self.register(name, module_name, type_name or "", shape)
+
+    def choice(
+        self,
+        name: str,
+        descriptor: dict[str, Any],
+        module_name: str,
+        type_name: str | None,
+    ) -> None:
+        self.blocks.append(
+            "class {}(_Methods):\n    _alternative: ClassVar[str]".format(name)
+        )
+        self.exported.append(name)
+        alternatives = []
+        attributes: dict[str, str] = {}
+
+        scope = descriptor.get("module-name", module_name)
+
+        for member, _ in self.members(descriptor):
+            asn1_name = member["name"]
+            alternative = self.take(
+                name + camel(asn1_name),
+                "the alternative {} of {}".format(asn1_name, name),
+            )
+            annotation, shape = self.annotate(
+                member, scope, name + "-" + asn1_name + "-value"
+            )
+            attributes[asn1_name] = alternative
+
+            self.blocks.append(
+                "@dataclasses.dataclass\n"
+                "class {}({}):\n"
+                "    value: {}\n"
+                "    _alternative: ClassVar[str] = {!r}".format(
+                    alternative, name, annotation, asn1_name
+                )
+            )
+            self.exported.append(alternative)
+            alternatives.append("{!r}: ({}, {}),".format(asn1_name, alternative, shape))
+
+        shape = '("choice", _alternatives({{{}}}))'.format(" ".join(alternatives))
+        self.register(name, module_name, type_name or "", shape)
+
+    def enumerated(
+        self,
+        name: str,
+        descriptor: dict[str, Any],
+        module_name: str,
+        type_name: str | None,
+    ) -> None:
+        lines = ["class {}(_Methods, enum.Enum):".format(name)]
+        members: dict[str, str] = {}
+
+        for value in descriptor["values"]:
+            if value is None:
+                continue
+
+            asn1_name = value[0]
+            member = snake(asn1_name).upper()
+
+            if member in members:
+                raise GenerateError(
+                    "Both {} and {} of {} are called {} in Python.".format(
+                        members[member], asn1_name, name, member
+                    )
+                )
+
+            members[member] = asn1_name
+            lines.append("    {} = {!r}".format(member, asn1_name))
+
+        if not members:
+            lines.append("    pass")
+
+        self.blocks.append("\n".join(lines))
+        self.exported.append(name)
+        self.register(name, module_name, type_name or "", '("enum", {})'.format(name))
+
+    # The whole module.
+
+    def type_assignment(
+        self, module_name: str, type_name: str, descriptor: dict[str, Any]
+    ) -> None:
+        name = self.names[(module_name, type_name)]
+        kind = self.kind_of(descriptor)
+
+        if kind == "sequence":
+            self.sequence(name, descriptor, module_name, type_name)
+        elif kind == "choice":
+            self.choice(name, descriptor, module_name, type_name)
+        elif kind == "enumerated":
+            self.enumerated(name, descriptor, module_name, type_name)
+        else:
+            annotation, shape = self.alias((module_name, type_name), descriptor)
+            function = snake(name)
+            self.alias_blocks.append('{}: TypeAlias = "{}"'.format(name, annotation))
+            self.exported.extend([name, "encode_" + function, "decode_" + function])
+            self.functions.append(
+                "def encode_{function}(\n"
+                "    value: {name},\n"
+                "    codec: CodecType = DEFAULT_CODEC,\n"
+                "    check_types: bool = True,\n"
+                "    check_constraints: bool = False,\n"
+                ") -> bytes:\n"
+                "    return _encode(\n"
+                "        ({module!r}, {type!r}),\n"
+                "        {shape},\n"
+                "        value,\n"
+                "        codec,\n"
+                "        check_types,\n"
+                "        check_constraints,\n"
+                "    )\n\n\n"
+                "def decode_{function}(\n"
+                "    data: bytes | bytearray,\n"
+                "    codec: CodecType = DEFAULT_CODEC,\n"
+                "    check_constraints: bool = False,\n"
+                ") -> {name}:\n"
+                "    return _decode(\n"
+                "        ({module!r}, {type!r}), {shape}, data, codec, check_constraints\n"
+                "    )".format(
+                    function=function,
+                    name=name,
+                    module=module_name,
+                    type=type_name,
+                    shape=shape,
+                )
+            )
+
+    def run(self) -> str:
+        self.name_the_types()
+
+        for module_name, module in self.modules.items():
+            for type_name, descriptor in module["types"].items():
+                self.type_assignment(module_name, type_name, descriptor)
+
+        # The classes made for types inside others have no name of their
+        # own in the specification.
+        header = HEADER.format(
+            version=self.version,
+            sources=", ".join(self.sources) or "a specification",
+            codec=self.codec,
+            asni=format_bytes(self.asni),
+        )
+        parts = [
+            header,
+            "\n\n" + REGISTER,
+            "\n\n\n".join(self.blocks),
+            "\n".join(self.registrations),
+            "\n".join(self.alias_blocks),
+            "\n\n\n".join(self.functions),
+            "__all__ = [\n{}]".format(
+                "".join("    {!r},\n".format(name) for name in self.exported)
+            ),
+        ]
+
+        return "\n\n\n".join(part.strip("\n") for part in parts if part.strip()) + "\n"
+
+
+REGISTER = """\
+def _register(
+    class_: Any, asn1_type: tuple[str, str], shape: Any
+) -> None:
+    class_._asn1_type = asn1_type
+    class_._shape = shape"""
+
+
+def format_bytes(data: bytes) -> str:
+    lines = []
+
+    for offset in range(0, len(data), 24):
+        chunk = data[offset : offset + 24]
+        lines.append(
+            '    b"{}"'.format("".join("\\x{:02x}".format(byte) for byte in chunk))
+        )
+
+    return "\n".join(lines) if lines else '    b""'
+
+
+def generate(
+    asni: bytes,
+    sources: list[str] | None = None,
+    codec: str = DEFAULT_CODEC,
+) -> 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.
+
+    """
+
+    try:
+        compiled = syntax.from_asni(asni)
+    except Exception as error:
+        raise GenerateError(
+            "Expected a compiled specification that is not signed, encrypted, "
+            "bound to something or has a nonce, but: {}".format(error)
+        )
+
+    return Generator(compiled, asni, sources or [], codec).run()

asnkit_gen_python/version.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2025 BoxTheta
+#
+# SPDX-License-Identifier: Apache-2.0
+
+__version__ = "1.0.1"

asnkit_gen_python-1.0.1.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: asnkit-gen-python
+Version: 1.0.1
+Summary: asnkit plugin that makes Python code with data classes from ASN.1
+Author: xadaemon
+Author-email: xadaemon <mxavier@boxtheta.com>
+License-Expression: Apache-2.0
+License-File: LICENSE-COMPILER
+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-Python: >=3.13
+Project-URL: source, https://github.com/boxtheta/asnkit
+Description-Content-Type: text/x-rst
+
+asnkit-gen-python
+=================
+
+A plugin for `asnkitcc`_ that generates Python code from ASN.1. The
+generated module imports `asnkitrt`_ and 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.
+
+.. code-block:: text
+
+   $ pip install asnkit-gen-python
+   $ asnkitcc generate --plugin python -o out foo.asn    # Writes out/foo.py.
+
+.. code-block:: python
+
+   >>> from foo import Question
+   >>> encoded = Question(id=1, question='Is 1+1=3?').encode('uper')
+   >>> Question.decode(encoded, 'uper')
+   Question(id=1, question='Is 1+1=3?')
+
+Options, given with ``--plugin-opt KEY=VALUE``:
+
+``name``
+   The name of the module, without ``.py``. Default: the name of the
+   first ASN.1 file.
+
+``codec``
+   The codec used when none is given. Default: ``ber``.
+
+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.
+
+.. _asnkitcc: https://crates.io/crates/asnkitcc
+
+.. _asnkitrt: https://pypi.org/project/asnkitrt/
+
+License
+-------
+
+Apache License 2.0 (``LICENSE-COMPILER``). The generated code, with the
+helper code copied into it, is yours to use under terms of your choice,
+as the header of each file it writes says. The generated code depends on
+``asnkitrt``,
+which is MIT licensed.

asnkit_gen_python-1.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+asnkit_gen_python/__init__.py,sha256=-hHOTKkPIWhYCsTSi8u1o9NkFOZPzb9KqjkziUQ-OhE,302
+asnkit_gen_python/__main__.py,sha256=xiAucIWkcJ2FDPkyYE9H9ERf7FH31VBl3actIbDTxfo,101
+asnkit_gen_python/cli.py,sha256=Tgl2yb74CsihoF8GiY9mq32_XMjP9PtcLANQyhJpY0M,3044
+asnkit_gen_python/generate.py,sha256=FuS8ZStFC3h7Fe4ILUv_J86JRtxPytE5RVYVyoRF4E0,23856
+asnkit_gen_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asnkit_gen_python/version.py,sha256=d8hfbFYDJ0fCZqkABAtCBI1bcRIm-zHO3ToQ5quUyUU,93
+asnkit_gen_python-1.0.1.dist-info/licenses/LICENSE-COMPILER,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+asnkit_gen_python-1.0.1.dist-info/WHEEL,sha256=9IUYslYuG_asT4WlWvfk_K76nveuLvSTKDoLeL0cV-Q,80
+asnkit_gen_python-1.0.1.dist-info/entry_points.txt,sha256=4tq6qQZh-ExXQSRBx6f8hEMdkjAGEMLs2xCeeMCPDXA,66
+asnkit_gen_python-1.0.1.dist-info/METADATA,sha256=v1zqfLaBczpou1Bg5WKyGlpR_QK9L0nQzm5fQ4lhCVI,2105
+asnkit_gen_python-1.0.1.dist-info/RECORD,,

asnkit_gen_python-1.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.1
+Root-Is-Purelib: true
+Tag: py3-none-any

asnkit_gen_python-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+asnkit-gen-python = asnkit_gen_python.cli:main
+

asnkit_gen_python-1.0.1.dist-info/licenses/LICENSE-COMPILER

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.