structurize 3.5.4__tar.gz → 3.5.6__tar.gz

{structurize-3.5.4/structurize.egg-info → structurize-3.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.5.4
+Version: 3.5.6
 Summary: Tools to convert from and to JSON Structure from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Classifier: Programming Language :: Python :: 3

{structurize-3.5.4 → structurize-3.5.6}/avrotize/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.5.4'
-__version_tuple__ = version_tuple = (3, 5, 4)
+__version__ = version = '3.5.6'
+__version_tuple__ = version_tuple = (3, 5, 6)
 
-__commit_id__ = commit_id = 'g783dbb9df'
+__commit_id__ = commit_id = 'g8153c67a3'

{structurize-3.5.4 → structurize-3.5.6}/avrotize/structuretopython.py

@@ -489,6 +489,36 @@ class StructureToPython:
         field_docstring = f"{field_name} ({field_type})"
         return field_docstring
 
+    def _python_enum_member_name(self, value) -> str:
+        """Derives a valid Python identifier for an enum member from a JSON
+        Structure enum value.
+
+        Numeric values (including negative integers) are prefixed with
+        ``VALUE_`` (with negatives spelled ``VALUE_NEG_n``) so the generated
+        class body is valid Python. String values that aren't already valid
+        identifiers — e.g. they start with a digit or contain hyphens/spaces —
+        are coerced via ``pascal`` and prefixed with ``VALUE_`` if they still
+        don't start with a letter or underscore. Reserved words get a
+        trailing underscore.
+        """
+        if isinstance(value, bool):
+            return "TRUE_" if value else "FALSE_"
+        if isinstance(value, (int, float)):
+            if isinstance(value, float):
+                token = str(value).replace('.', '_').replace('-', 'NEG_')
+            elif value < 0:
+                token = f"NEG_{abs(value)}"
+            else:
+                token = str(value)
+            return f"VALUE_{token}"
+        text = str(value)
+        candidate = re.sub(r'[^0-9A-Za-z_]', '_', text)
+        if not candidate or not (candidate[0].isalpha() or candidate[0] == '_'):
+            candidate = f"VALUE_{candidate}" if candidate else "VALUE_"
+        if is_python_reserved_word(candidate):
+            candidate = candidate + "_"
+        return candidate
+
     def generate_enum(self, structure_schema: Dict, field_name: str, parent_namespace: str, 
                      write_file: bool) -> str:
         """ Generates a Python enum from JSON Structure enum """
@@ -502,8 +532,24 @@ class StructureToPython:
         if python_qualified_name in self.generated_types:
             return python_qualified_name
 
-        symbols = [symbol if not is_python_reserved_word(symbol) else symbol + "_" 
-                  for symbol in structure_schema.get('enum', [])]
+        raw_values = structure_schema.get('enum', [])
+        is_numeric = bool(raw_values) and all(
+            isinstance(v, (int, float)) and not isinstance(v, bool) for v in raw_values
+        )
+
+        # Build (member_name, repr) pairs. ``repr`` is rendered verbatim into the
+        # class body, so for numeric enums we emit the bare numeric literal and
+        # for string enums a quoted Python string literal.
+        members: List[Tuple[str, str]] = []
+        symbols: List[str] = []
+        for value in raw_values:
+            member_name = self._python_enum_member_name(value)
+            if is_numeric:
+                value_repr = repr(value)
+            else:
+                value_repr = repr(str(value))
+            members.append((member_name, value_repr))
+            symbols.append(member_name)
 
         doc = structure_schema.get('description', structure_schema.get('doc', f'A {class_name} enum.'))
 
@@ -511,12 +557,15 @@ class StructureToPython:
             "structuretopython/enum_core.jinja",
             class_name=class_name,
             docstring=doc,
+            members=members,
+            is_numeric=is_numeric,
+            # ``symbols`` kept for backward compatibility with any external use
             symbols=symbols,
         )
 
         if write_file:
             self.write_to_file(package_name, class_name, enum_definition)
-            self.generate_test_enum(package_name, class_name, symbols)
+            self.generate_test_enum(package_name, class_name, members, is_numeric)
 
         self.generated_types[python_qualified_name] = 'enum'
         self.generated_enum_symbols[python_qualified_name] = symbols
@@ -717,7 +766,8 @@ class StructureToPython:
         with open(test_file_path, 'w', encoding='utf-8') as file:
             file.write(test_class_definition)
 
-    def generate_test_enum(self, package_name: str, class_name: str, symbols: List[str]) -> None:
+    def generate_test_enum(self, package_name: str, class_name: str,
+                           members: List[Tuple[str, str]], is_numeric: bool) -> None:
         """Generates a unit test class for a Python enum"""
         test_class_name = f"Test_{class_name}"
         # Use a simpler file naming scheme based on class name only
@@ -727,7 +777,8 @@ class StructureToPython:
             package_name=package_name,
             class_name=class_name,
             test_class_name=test_class_name,
-            symbols=symbols
+            members=members,
+            is_numeric=is_numeric,
         )
         base_dir = os.path.join(self.output_dir, "tests")
         test_file_path = os.path.join(base_dir, f"{test_file_name}.py")
@@ -812,6 +863,32 @@ class StructureToPython:
         with open(os.path.join(self.output_dir, 'pyproject.toml'), 'w', encoding='utf-8') as file:
             file.write(pyproject_content)
 
+    def process_definitions(self, definitions: Dict, namespace_path: str) -> None:
+        """ Recursively walks the definitions tree and generates a Python type for each leaf.
+
+        Leaves are sub-schemas that carry an ``enum`` keyword or a ``type`` of
+        ``object``/``choice``/``map``. Other dict entries are treated as nested
+        namespace segments (matching the path-as-namespace convention used in
+        ``$root`` JSON pointers like ``#/definitions/de/wsv/pegelonline/Station``).
+        """
+        for name, definition in definitions.items():
+            if not isinstance(definition, dict):
+                continue
+            if 'enum' in definition:
+                self.generate_enum(definition, name, namespace_path, write_file=True)
+            elif definition.get('type') == 'object':
+                self.generate_class(definition, namespace_path, write_file=True, explicit_name=name)
+            elif definition.get('type') == 'choice':
+                self.generate_choice(definition, namespace_path, write_file=True, explicit_name=name)
+            elif definition.get('type') == 'map':
+                # generate_map_alias doesn't accept explicit_name; stamp the name on a copy.
+                map_schema = dict(definition)
+                map_schema.setdefault('name', name)
+                self.generate_map_alias(map_schema, namespace_path, write_file=True)
+            else:
+                new_namespace = f"{namespace_path}.{name}" if namespace_path else name
+                self.process_definitions(definition, new_namespace)
+
     def convert_schemas(self, structure_schemas: List, output_dir: str):
         """ Converts JSON Structure schemas to Python dataclasses"""
         self.output_dir = output_dir
@@ -827,15 +904,48 @@ class StructureToPython:
             if 'definitions' in structure_schema:
                 self.definitions = structure_schema['definitions']
 
+            handled = False
             if 'enum' in structure_schema:
-                self.generate_enum(structure_schema, structure_schema.get('name', 'Enum'), 
+                self.generate_enum(structure_schema, structure_schema.get('name', 'Enum'),
                                  structure_schema.get('namespace', ''), write_file=True)
+                handled = True
             elif structure_schema.get('type') == 'object':
                 self.generate_class(structure_schema, structure_schema.get('namespace', ''), write_file=True)
+                handled = True
             elif structure_schema.get('type') == 'choice':
                 self.generate_choice(structure_schema, structure_schema.get('namespace', ''), write_file=True)
+                handled = True
             elif structure_schema.get('type') == 'map':
                 self.generate_map_alias(structure_schema, structure_schema.get('namespace', ''), write_file=True)
+                handled = True
+            elif '$root' in structure_schema:
+                # $root + definitions wrapper: resolve the pointer, derive the namespace
+                # from the pointer path (segments between 'definitions' and the type name),
+                # and emit the targeted class explicitly. Sibling types in `definitions`
+                # are picked up below by process_definitions.
+                root_ref = structure_schema['$root']
+                root_schema = self.resolve_ref(root_ref, structure_schema)
+                if root_schema:
+                    ref_path = root_ref.split('/')
+                    type_name = ref_path[-1]
+                    ref_namespace = '.'.join(ref_path[2:-1]) if len(ref_path) > 3 else ''
+                    self.generate_class_or_choice(root_schema, ref_namespace, write_file=True, explicit_name=type_name)
+                    handled = True
+
+            # Recursively walk the definitions tree so every named type is emitted,
+            # regardless of whether the top-level schema also dispatched something.
+            if 'definitions' in structure_schema:
+                self.process_definitions(structure_schema['definitions'], '')
+                handled = True
+
+            if not handled:
+                schema_id = structure_schema.get('$id', '<no $id>')
+                schema_name = structure_schema.get('name', '<no name>')
+                print(
+                    f"Warning: structure schema (id={schema_id}, name={schema_name}) did not "
+                    "match any recognized top-level shape (enum, type=object/choice/map, "
+                    "$root, or definitions); no Python output generated for it."
+                )
 
         self.write_init_files()
         self.write_pyproject_toml()

{structurize-3.5.4 → structurize-3.5.6/structurize.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.5.4
+Version: 3.5.6
 Summary: Tools to convert from and to JSON Structure from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Classifier: Programming Language :: Python :: 3