EmbeddedProto 4.0.0b1__py3-none-any.whl

EmbeddedProto/Oneof.py

@@ -0,0 +1,74 @@
+#
+# Copyright (C) 2020-2026 Embedded AMS B.V. - All Rights Reserved
+#
+# This file is part of Embedded Proto.
+#
+# Embedded Proto is dual licensed. You may use it under the terms of the
+# GNU General Public License version 3 (GPLv3) as published by the Free
+# Software Foundation, or under a commercial license from Embedded AMS B.V.
+#
+# Under the GPLv3 you must release the source code of
+# any product you distribute that includes Embedded Proto or code
+# generated by it. A commercial license removes that obligation.
+# See <https://embeddedproto.com/pricing/>.
+#
+# Embedded Proto is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the LICENSE file in the root of the repository for details.
+#
+# SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-EmbeddedProto-Commercial
+#
+# Embedded AMS B.V., Hoorn, the Netherlands - info at EmbeddedProto dot com
+#
+
+from .Field import Field
+
+
+class Oneof:
+    def __init__(self, oneof_proto_descriptor, index, msg_descriptor, parent_msg):
+        # A reference to the OneofDescriptorProto object which defines this field.
+        self.descriptor = oneof_proto_descriptor
+
+        # A reference to the parent message in which this oneof is defined.
+        self.parent = parent_msg
+
+        self.fields = []
+        # Loop over all the fields in this oneof
+        for f in msg_descriptor.field:
+            if f.HasField('oneof_index') and index == f.oneof_index:
+                new_field = Field.factory(f, self.parent, oneof=self)
+                self.fields.append(new_field)
+
+    def get_name(self):
+        return self.descriptor.name
+
+    def get_variable_name(self):
+        return self.get_name() + "_"
+
+    def get_which_oneof(self):
+        return "which_" + self.get_name()
+    
+    def get_which_method(self):
+        return "get_" + self.get_which_oneof() + "()"
+
+    def get_fields(self):
+        return self.fields
+
+    def match_field_with_definitions(self, all_types_definitions):
+        for field in self.fields:
+            field.match_field_with_definitions(all_types_definitions)
+
+    def register_template_parameters(self):
+        all_parameters_registered = True
+        for field in self.fields:
+            all_parameters_registered = field.register_template_parameters() and all_parameters_registered
+        return all_parameters_registered
+
+    # Returns true if in oneof.init the new& function needs to be call to initialize already allocated memory.
+    def oneof_allocation_required(self):
+        result = False
+        for field in self.fields:
+            result = field.oneof_allocation_required()
+            if result:
+                break
+        return result

EmbeddedProto/ProtoFile.py

@@ -0,0 +1,210 @@
+#
+# Copyright (C) 2020-2026 Embedded AMS B.V. - All Rights Reserved
+#
+# This file is part of Embedded Proto.
+#
+# Embedded Proto is dual licensed. You may use it under the terms of the
+# GNU General Public License version 3 (GPLv3) as published by the Free
+# Software Foundation, or under a commercial license from Embedded AMS B.V.
+#
+# Under the GPLv3 you must release the source code of
+# any product you distribute that includes Embedded Proto or code
+# generated by it. A commercial license removes that obligation.
+# See <https://embeddedproto.com/pricing/>.
+#
+# Embedded Proto is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the LICENSE file in the root of the repository for details.
+#
+# SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-EmbeddedProto-Commercial
+#
+# Embedded AMS B.V., Hoorn, the Netherlands - info at EmbeddedProto dot com
+#
+
+from .TypeDefinitions import *
+from .Features import FeatureResolver
+from . import field_options
+import os
+import sys
+from toposort import CircularDependencyError, toposort_flatten
+from google.protobuf import descriptor_pb2
+from google.protobuf.descriptor_pb2 import FieldDescriptorProto
+
+
+# Proto files for which no C++ code is generated. Our own options file only carries generator settings. The google
+# descriptor file only carries the definitions required to declare custom options, those definitions are used by protoc
+# and other plugins, not by the embedded target.
+EXCLUDED_PROTO_FILES = ("embedded_proto_options.proto", "google/protobuf/descriptor.proto")
+
+
+# Return true if no C++ code should be generated for the given proto file name.
+def is_excluded_proto_file(proto_filename):
+    return any(excluded in proto_filename for excluded in EXCLUDED_PROTO_FILES)
+
+
+# -----------------------------------------------------------------------------
+
+def toposort_add_msg(msg, namespace, dependency_data):
+
+    local_definitions = []
+    local_namespace = namespace + "." + msg.name
+
+    dependencies = {namespace}
+
+    for nested_msg in msg.nested_type:
+        dependency_data = toposort_add_msg(nested_msg, local_namespace, dependency_data)
+        full_msg_type = local_namespace + "." + nested_msg.name
+        local_definitions.append(full_msg_type)
+        for dep in dependency_data[full_msg_type]:
+            # Add requirements on other namespaces.
+            if not dep.startswith(local_namespace):
+                dependencies.add(dep)
+
+    for nested_enum in msg.enum_type:
+        full_enum_type = local_namespace + "." + nested_enum.name
+        dependency_data[full_enum_type] = {local_namespace}
+        local_definitions.append(full_enum_type)
+
+    for f in msg.field:
+        if ((FieldDescriptorProto.TYPE_MESSAGE == f.type) or (FieldDescriptorProto.TYPE_ENUM == f.type)) \
+                and (f.type_name not in local_definitions) \
+                and not f.type_name.startswith(local_namespace + "."):
+            dependencies.add(f.type_name)
+
+    # If we have any dependencies add them
+    if 0 < len(dependencies):
+        dependency_data[local_namespace] = dependencies
+
+    return dependency_data
+
+
+# -----------------------------------------------------------------------------
+
+class ProtoFile:
+    def __init__(self, proto_descriptor, options_file=None):
+        self.descriptor = proto_descriptor
+
+        # The external field options file, shared by every field in this run. None when no file was given.
+        self.options_file = options_file
+
+        if "proto2" == proto_descriptor.syntax:
+            raise Exception(proto_descriptor.name + ": Sorry, proto2 is not supported, please use proto3.")
+
+        # Select the edition feature profile for this file and resolve the
+        # file-scope feature set. proto3 maps to the proto3 profile so the existing
+        # generation path is a special case of the same machinery.
+        self.feature_resolver = FeatureResolver(proto_descriptor)
+        self.file_features = self.feature_resolver.file_features
+
+        # These file names are the ones used for creating the C++ files.
+        self.filename_with_folder = os.path.splitext(proto_descriptor.name)[0]
+        self.filename_without_folder = os.path.basename(self.filename_with_folder)
+
+        # Construct the base scope used in this file.
+        self.scope = None
+        if self.descriptor.package:
+            package_list = self.descriptor.package.split(".")
+            # The first element is the base scope.
+            self.scope = Scope(package_list[0], None)
+            # Next add additional scopes nesting the previous one.
+            for package in package_list[1:]:
+                self.scope = Scope(package, self.scope)
+
+        self.enum_definitions = [EnumDefinition(enum, self.scope, self.feature_resolver, self.file_features)
+                                 for enum in self.descriptor.enum_type]
+        self.msg_definitions = [MessageDefinition(msg, self.scope, self.feature_resolver, self.file_features,
+                                                  self.options_file)
+                                for msg in self.descriptor.message_type]
+
+        self.all_parameters_registered = False
+
+        # Sort the message definitions such that the dependencies work out.
+        dependency_data = {}
+        toposort_namespace = ""
+        if self.descriptor.package:
+            toposort_namespace = "." + self.descriptor.package
+
+        for msg in self.descriptor.message_type:
+            dependency_data = toposort_add_msg(msg, toposort_namespace, dependency_data)
+
+        try:
+            # Sort the message in the order they should appear in the code.
+            message_order = toposort_flatten(dependency_data)
+
+            # If we are in a namespace this appears in the list and should be removed.
+            my_scope = ""
+            if self.scope and (0 < len(message_order)):
+                my_scope = "." + self.scope.get_scope_str().replace("::", ".")
+                message_order.remove(my_scope)
+
+            # Based on the desired order assign each message definition an index.
+            for index, msg_name in enumerate(message_order):
+                for msg_def in self.msg_definitions:
+                    if msg_def.name == msg_name.replace(my_scope + ".", ''):
+                        msg_def.sorted_index = index
+                        break
+
+            # Next sort the messages based on their index.
+            self.msg_definitions.sort(key=lambda msg: msg.sorted_index)
+
+            # Sort al the nested message definitions.
+            for msg in self.msg_definitions:
+                msg.sort_nested_msg_definitions(message_order)
+
+        except CircularDependencyError as e:
+            raise Exception("There are possible circular dependencies in the message definitions of "
+                            + proto_descriptor.name + ". Embedded Proto is not able to support this. "
+                            "Please remove these dependencies.")
+
+    def get_dependencies(self):
+        imported_dependencies = []
+        if self.descriptor.dependency:
+            extension = self.options_file.header_extension() if self.options_file is not None else field_options.DEFAULT_HEADER_EXTENSION
+            imported_dependencies = [os.path.splitext(dependency)[0] + extension for dependency in
+                                     self.descriptor.dependency if not is_excluded_proto_file(dependency)]
+        return imported_dependencies
+
+    def get_namespaces(self):
+        if self.scope:
+            result = self.scope.get_list_of_scope_str()
+        else:
+            result = []
+        return result
+
+    def get_header_guard(self):
+        return self.filename_with_folder.replace("/", "_").upper()
+
+    # Obtain a dictionary with references to all nested enums and messages
+    def get_all_nested_types(self):
+        nested_types = {"enums": [], "messages": []}
+        nested_types["enums"].extend(self.enum_definitions)
+        for msg in self.msg_definitions:
+            nt = msg.get_all_nested_types()
+            nested_types["enums"].extend(nt["enums"])
+            nested_types["messages"].extend(nt["messages"])
+            nested_types["messages"].append(msg)
+
+        return nested_types
+
+    def match_fields_with_definitions(self, all_types_definitions):
+        for msg in self.msg_definitions:
+            msg.match_fields_with_definitions(all_types_definitions)
+
+    def register_template_parameters(self):
+        all_parameters_registered = True
+        for msg in self.msg_definitions:
+            all_parameters_registered = msg.register_template_parameters() and all_parameters_registered
+        return all_parameters_registered
+
+    def render(self, jinja_environment):
+        template_file = "Header.h.jinja2"
+        template = jinja_environment.get_template(template_file)
+        file_str = template.render(proto_file=self, environment=jinja_environment)
+        return file_str
+
+    def print_template_data(self, indent):
+        print(indent + "File: " + self.filename_without_folder)
+        if self.msg_definitions:
+            for msg in self.msg_definitions:
+                msg.print_template_data(indent + "\t")
+

EmbeddedProto/TypeDefinitions.py

@@ -0,0 +1,367 @@
+#
+# Copyright (C) 2020-2026 Embedded AMS B.V. - All Rights Reserved
+#
+# This file is part of Embedded Proto.
+#
+# Embedded Proto is dual licensed. You may use it under the terms of the
+# GNU General Public License version 3 (GPLv3) as published by the Free
+# Software Foundation, or under a commercial license from Embedded AMS B.V.
+#
+# Under the GPLv3 you must release the source code of
+# any product you distribute that includes Embedded Proto or code
+# generated by it. A commercial license removes that obligation.
+# See <https://embeddedproto.com/pricing/>.
+#
+# Embedded Proto is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the LICENSE file in the root of the repository for details.
+#
+# SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-EmbeddedProto-Commercial
+#
+# Embedded AMS B.V., Hoorn, the Netherlands - info at EmbeddedProto dot com
+#
+
+from .Field import Field
+from .Oneof import Oneof
+import jinja2
+
+
+# This class deal with the scope in which definitions and field are located. It is used to keep track of template
+# parameters required for a given scope.
+class Scope:
+    def __init__(self, scope_name, parent):
+        # The name of this scope/namespace
+        self.name = scope_name
+
+        # A reference to the scope above this scope. If we are at the top level this will be None.
+        self.parent = parent
+
+        # Start of without any children.
+        self.child_scopes = []
+
+        # Register this object with it's parent.
+        if self.parent:
+            self.parent.child_scopes.append(self)
+
+        self.fields_with_templates = []
+
+    # This function is used
+    def get_list_of_scope_str(self):
+        if self.parent:
+            result = self.parent.get_list_of_scope_str()
+            result.append(self.name)
+        else:
+            result = [self.name]
+        return result
+
+    # When searching for the definition of a field this function returns a scope string equal to the type defined by
+    # protobuf.
+    def get_scope_str(self):
+        if self.parent:
+            scope_str = self.parent.get_scope_str() + "::" + self.name
+        else:
+            scope_str = self.name
+
+        return scope_str
+
+    def register_template_parameters(self, field):
+        # Guard against duplicate registration. This can happen because FieldRepeated now unconditionally registers
+        # itself, and a nested message field may trigger a second registration through its own register chain.
+        if field not in self.fields_with_templates:
+            self.fields_with_templates.append(field)
+
+    # Return the list of template parameters required for this scope alone.
+    def get_template_parameters(self):
+        # Collect all template parameters from every field that registered with this scope.
+        result = []
+        for field in self.fields_with_templates:
+            result.extend(field.get_template_parameters())
+
+        # Multiple fields may contribute parameters with the same name (e.g. when a field registers both through
+        # the repeated path and the nested message path). De-duplicate by name, keeping first-seen order.
+        unique = []
+        seen = set()
+        for param in result:
+            if param["name"] not in seen:
+                unique.append(param)
+                seen.add(param["name"])
+
+        # In C++ template parameter lists, parameters with default values must appear after those without. Separate
+        # them to enforce this ordering.
+        non_default = [param for param in unique if "default" not in param]
+        defaulted = [param for param in unique if "default" in param]
+
+        # Backward compatibility: if a message only has defaulted template parameters (e.g. a message where all
+        # repeated fields have a fixed maxLength and only contribute the storage type parameter), suppress them
+        # entirely. This prevents turning a previously non-templated message into a template class, which would
+        # break existing user code that instantiates it without template arguments.
+        if not non_default:
+            return []
+
+        return non_default + defaulted
+
+    # Return a full list of the scope, parent scopes and their templates
+    def get(self):
+        result = []
+        if self.parent:
+            result.extend(self.parent.get())
+        result.extend([{"name": self.name, "templates": self.get_template_parameters()}])
+        return result
+
+# -----------------------------------------------------------------------------
+
+
+class TypeDefinition:
+    def __init__(self, proto_descriptor, parent_scope, template_filename,
+                 feature_resolver=None, enclosing_features=None):
+        self.descriptor = proto_descriptor
+        self.name = proto_descriptor.name
+        self.scope = Scope(self.name, parent_scope)
+        self.template_file = template_filename
+
+        # Editions feature resolution. The resolver picks the edition profile; the
+        # enclosing features are the resolved feature set of the parent scope (file
+        # or enclosing message). This type's own explicit overrides are merged on
+        # top to obtain its resolved feature set. proto3 files use the proto3
+        # profile so this is always populated.
+        self.feature_resolver = feature_resolver
+        if feature_resolver is not None:
+            base = enclosing_features if enclosing_features is not None \
+                else feature_resolver.file_features
+            self.features = feature_resolver.merge(base, proto_descriptor.options,
+                                                   self.scope.get_scope_str())
+        else:
+            self.features = None
+
+    def get_name(self):
+        return self.name
+
+    def render(self, jinja_environment):
+        template = jinja_environment.get_template(self.template_file)
+        render_result = template.render(typedef=self, environment=jinja_environment)
+        return render_result
+
+
+# -----------------------------------------------------------------------------
+
+class EnumDefinition(TypeDefinition):
+    def __init__(self, proto_descriptor, parent_scope, feature_resolver=None, enclosing_features=None):
+        super().__init__(proto_descriptor, parent_scope, "TypeDefEnum.h.jinja2",
+                         feature_resolver, enclosing_features)
+
+    # Loop through the values defined in the enum.
+    def values(self):
+        for value in self.descriptor.value:
+            yield value
+
+    # Whether this enum is CLOSED (editions enum_type feature). Closed enums
+    # validate decoded values and drop unknown ones; open enums store any value.
+    def is_closed(self):
+        from .Features import EnumType
+        if self.features is not None:
+            return EnumType.CLOSED == self.features["enum_type"]
+        return False
+
+    # The distinct value numbers declared in this enum (aliases collapsed), used to
+    # generate the CLOSED-enum validation helper without duplicate switch labels.
+    def unique_value_numbers(self):
+        seen = []
+        for value in self.descriptor.value:
+            if value.number not in seen:
+                seen.append(value.number)
+        return seen
+
+
+# -----------------------------------------------------------------------------
+
+class MessageDefinition(TypeDefinition):
+    def __init__(self, proto_descriptor, parent_scope, feature_resolver=None, enclosing_features=None,
+                 options_file=None):
+        super().__init__(proto_descriptor, parent_scope, "TypeDefMsg.h.jinja2",
+                         feature_resolver, enclosing_features)
+
+        # The external field options file. The fields of this message read their options from it, they reach it
+        # through their parent message the same way they reach the feature resolver.
+        self.options_file = options_file
+
+        self.nested_enum_definitions = [EnumDefinition(enum, self.scope, self.feature_resolver, self.features)
+                                        for enum in self.descriptor.enum_type]
+        self.nested_msg_definitions = [MessageDefinition(msg, self.scope, self.feature_resolver, self.features,
+                                                        self.options_file)
+                                       for msg in self.descriptor.nested_type]
+
+        # Store the id numbers of all the fields to create the ID enum.
+        self.field_ids = []
+
+        # This message contains optional fields, or not.
+        self.optional_fields = []
+
+        # Store all the variable fields in this message.
+        self.fields = []
+        for f in self.descriptor.field:
+            if (not f.HasField('oneof_index')) or f.proto3_optional:
+                new_field = Field.factory(f, self)
+                self.fields.append(new_field)
+                self.field_ids.append((new_field.variable_id, new_field.variable_id_name))
+
+                # Store for which fields presence needs to be tracked. This now
+                # follows the resolved editions field_presence feature (EXPLICIT
+                # fields are optional) of which proto3_optional is a special case.
+                if new_field.optional:
+                    self.optional_fields.append(new_field)
+
+        # Store all the oneof definitions in this message.
+        self.oneofs = []
+        for index, oneof in enumerate(self.descriptor.oneof_decl):
+            new_oneof = Oneof(oneof, index, proto_descriptor, self)
+            oneof_fields = new_oneof.get_fields()
+            # For backwards compatibility proto3 optional fields are also include as oneof's with a single field. These
+            # dummy oneof's should not actually end up in code. Lets filter them out.
+            if oneof_fields[0].optional:
+                continue
+            else:
+                self.oneofs.append(new_oneof)
+                for oneof_field in new_oneof.get_fields():
+                    self.field_ids.append((oneof_field.variable_id, oneof_field.variable_id_name))
+
+        # Sort the field id's such they will appear in order in the id enum.
+        self.field_ids.sort()
+
+        # Not all template parameters for this message definition have been registered with the scope. This is
+        # most likely due to a message defined later in the proto file.
+        self.all_parameters_registered = False
+
+        # Does this message definition contains fields with template parameters.
+        self.contains_template_parameters = False
+
+        # The index where in the source file this definition should be placed. This is later set by the ProtoFile class
+        # when the dependencies on other messages has been sorted.
+        self.sorted_index = 0
+
+    # Sort the nested message defintions based on the dependencies found by the sort algorithms.
+    def sort_nested_msg_definitions(self, message_order):
+        my_scope = "." + self.scope.get_scope_str().replace("::", ".")
+
+        for index, msg_name in enumerate(message_order):
+            for msg_def in self.nested_msg_definitions:
+                if msg_def.name == msg_name.replace(my_scope + ".", ''):
+                    msg_def.sorted_index = index
+                    break
+
+        # Next sort the messages based on their index.
+        self.nested_msg_definitions.sort(key=lambda msg: msg.sorted_index)
+
+        # Sort al the nested message definitions in the nested message definitions.
+        for nested_msg in self.nested_msg_definitions:
+            nested_msg.sort_nested_msg_definitions(message_order)
+
+    # Obtain a dictionary with references to all nested enums and messages
+    def get_all_nested_types(self):
+        nested_types = {"enums": [], "messages": []}
+        nested_types["enums"].extend(self.nested_enum_definitions)
+        for msg in self.nested_msg_definitions:
+            nt = msg.get_all_nested_types()
+            nested_types["enums"].extend(nt["enums"])
+            nested_types["messages"].extend(nt["messages"])
+            nested_types["messages"].append(msg)
+
+        return nested_types
+
+    def match_fields_with_definitions(self, all_types_definitions):
+        # Resolve the types of the nested messages.
+        for msg in self.nested_msg_definitions:
+            msg.match_fields_with_definitions(all_types_definitions)
+
+        # Resolve the types of the fields defined in this message.
+        for field in self.fields:
+            field.match_field_with_definitions(all_types_definitions)
+
+        for oneof in self.oneofs:
+            oneof.match_field_with_definitions(all_types_definitions)
+
+    # TODO This function will fail to return True if this definitions contains it self as a nested field.
+    def register_template_parameters(self):
+        self.all_parameters_registered = True
+        # First resolve the template parameters for all nested message definitions.
+        for nested_msg in self.nested_msg_definitions:
+            self.all_parameters_registered = nested_msg.register_template_parameters() \
+                                             and self.all_parameters_registered
+
+        # Next see if we our self have any fields that have template parameters.
+        for field in self.fields:
+            self.all_parameters_registered = field.register_template_parameters() and self.all_parameters_registered
+
+        for oneof in self.oneofs:
+            self.all_parameters_registered = oneof.register_template_parameters() and self.all_parameters_registered
+
+        return self.all_parameters_registered
+
+    def register_child_with_template(self, child):
+        self.scope.register_template_parameters(child)
+        self.contains_template_parameters = True
+
+    def get_templates(self):
+        return self.scope.get_template_parameters()
+
+    def get_type(self):
+        return self.scope.get_scope_str()
+
+    # The full protobuf name of this message, package and enclosing messages included, as it appears in the type url of
+    # a google.protobuf.Any.
+    def get_full_name(self):
+        return self.scope.get_scope_str().replace("::", ".")
+
+    def get_state_depth(self):
+        """
+        Calculate the required state depth for this message.
+        
+        Returns:
+            int: Minimum 1, plus maximum depth of nested message fields.
+        
+        Examples:
+            - message Simple { int32 a = 1; } -> depth = 1
+            - message A { B b = 1; } where B has no nested -> depth = 2
+            - message A { B b = 1; } where B { C c = 1; } -> depth = 3
+        """
+        max_nested_depth = 0
+        
+        for field in self.fields:
+            # Check if this is a message field
+            if hasattr(field, 'definition') and field.definition is not None:
+                if isinstance(field.definition, MessageDefinition):
+                    nested_depth = field.definition.get_state_depth()
+                    if nested_depth > max_nested_depth:
+                        max_nested_depth = nested_depth
+            # Check for repeated message fields
+            elif hasattr(field, 'actual_type') and hasattr(field.actual_type, 'definition'):
+                if field.actual_type.definition is not None and isinstance(field.actual_type.definition, MessageDefinition):
+                    nested_depth = field.actual_type.definition.get_state_depth()
+                    if nested_depth > max_nested_depth:
+                        max_nested_depth = nested_depth
+        
+        # Check oneof fields as well
+        for oneof in self.oneofs:
+            for field in oneof.get_fields():
+                if hasattr(field, 'definition') and field.definition is not None:
+                    if isinstance(field.definition, MessageDefinition):
+                        nested_depth = field.definition.get_state_depth()
+                        if nested_depth > max_nested_depth:
+                            max_nested_depth = nested_depth
+                elif hasattr(field, 'actual_type') and hasattr(field.actual_type, 'definition'):
+                    if field.actual_type.definition is not None and isinstance(field.actual_type.definition, MessageDefinition):
+                        nested_depth = field.actual_type.definition.get_state_depth()
+                        if nested_depth > max_nested_depth:
+                            max_nested_depth = nested_depth
+        
+        return 1 + max_nested_depth  # +1 for this message itself
+
+    def print_template_data(self, indent):
+        print(indent + "Message definition: " + self.name)
+        if self.nested_msg_definitions:
+            for msg in self.nested_msg_definitions:
+                msg.print_template_data(indent + "\t")
+
+        if self.fields:
+            for field in self.fields:
+                print(indent + "Field: " + field.name, end='')
+                print(field.get_template_parameters())

EmbeddedProto/__main__.py

@@ -0,0 +1,28 @@
+#
+# Copyright (C) 2020-2026 Embedded AMS B.V. - All Rights Reserved
+#
+# This file is part of Embedded Proto.
+#
+# Embedded Proto is dual licensed. You may use it under the terms of the
+# GNU General Public License version 3 (GPLv3) as published by the Free
+# Software Foundation, or under a commercial license from Embedded AMS B.V.
+#
+# Under the GPLv3 you must release the source code of
+# any product you distribute that includes Embedded Proto or code
+# generated by it. A commercial license removes that obligation.
+# See <https://embeddedproto.com/pricing/>.
+#
+# Embedded Proto is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the LICENSE file in the root of the repository for details.
+#
+# SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-EmbeddedProto-Commercial
+#
+# Embedded AMS B.V., Hoorn, the Netherlands - info at EmbeddedProto dot com
+#
+
+from .main import main
+
+
+if __name__ == '__main__':
+    main()