structurize 2.16.5__tar.gz → 2.17.0__tar.gz

structurize-2.17.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: structurize
+Version: 2.17.0
+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
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema>=4.23.0
+Requires-Dist: lark>=1.1.9
+Requires-Dist: pyarrow>=22.0.0
+Requires-Dist: asn1tools>=0.167.0
+Requires-Dist: jsonpointer>=3.0.0
+Requires-Dist: jsonpath-ng>=1.6.1
+Requires-Dist: jsoncomparison>=1.1.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: azure-kusto-data>=5.0.5
+Requires-Dist: azure-identity>=1.17.1
+Requires-Dist: datapackage>=1.15.4
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: pyiceberg>=0.10.0
+Requires-Dist: pandas>=2.2.2
+Requires-Dist: docker>=7.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.2; extra == "dev"
+Requires-Dist: fastavro>=1.9.5; extra == "dev"
+Requires-Dist: xmlschema>=3.3.2; extra == "dev"
+Requires-Dist: xmlunittest>=1.0.1; extra == "dev"
+Requires-Dist: pylint>=3.2.6; extra == "dev"
+Requires-Dist: dataclasses_json>=0.6.7; extra == "dev"
+Requires-Dist: dataclasses>=0.8; extra == "dev"
+Requires-Dist: pydantic>=2.8.2; extra == "dev"
+Requires-Dist: avro>=1.12.0; extra == "dev"
+Requires-Dist: testcontainers>=4.7.2; extra == "dev"
+Requires-Dist: pymysql>=1.1.1; extra == "dev"
+Requires-Dist: psycopg2>=2.9.9; extra == "dev"
+Requires-Dist: pyodbc>=5.1.0; extra == "dev"
+Requires-Dist: pymongo>=4.8.0; extra == "dev"
+Requires-Dist: oracledb>=2.3.0; extra == "dev"
+Requires-Dist: cassandra-driver>=3.29.1; extra == "dev"
+Requires-Dist: sqlalchemy>=2.0.32; extra == "dev"
+Dynamic: license-file
+
+# Structurize / Avrotize
+
+**Structurize** is a powerful schema conversion toolkit that helps you transform between various schema formats including JSON Schema, JSON Structure, Avro Schema, Protocol Buffers, XSD, SQL, and many more.
+
+This package is published under two names:
+
+- **`structurize`** - The primary package name, emphasizing JSON Structure conversion capabilities
+- **`avrotize`** - The original package name, emphasizing Avro Schema conversion capabilities
+
+Both packages currently share the same features and codebase. However, in future releases, Avro-focused and JSON Structure-focused features may be split across the two tools to make the feature list more manageable and focused for users. Choose whichever variant better aligns with your primary use case.
+
+## Quick Start
+
+Install the package:
+
+```bash
+pip install structurize
+```
+
+or
+
+```bash
+pip install avrotize
+```
+
+Use the CLI:
+
+```bash
+# Using structurize
+structurize --help
+
+# Or using avrotize
+avrotize --help
+```
+
+## Key Features
+
+- Convert between JSON Schema, JSON Structure, and Avro Schema
+- Transform schemas to and from Protocol Buffers, XSD, ASN.1
+- Generate code in C#, Python, TypeScript, Java, Go, Rust, C++, JavaScript
+- Export schemas to SQL databases (MySQL, PostgreSQL, SQL Server, Oracle, Cassandra, MongoDB, DynamoDB, and more)
+- Convert to Parquet, Iceberg, Kusto, and other data formats
+- Generate documentation in Markdown
+
+## Documentation
+
+For complete documentation, examples, and detailed usage instructions, please see the main repository:
+
+**[📖 Full Documentation](https://github.com/clemensv/avrotize)**
+
+The main README includes:
+
+- Comprehensive command reference
+- Conversion examples and use cases
+- Code generation guides
+- Database schema export instructions
+- API documentation
+
+## License
+
+MIT License - see the [LICENSE](../LICENSE) file in the repository root.

structurize-2.17.0/README.md

@@ -0,0 +1,61 @@
+# Structurize / Avrotize
+
+**Structurize** is a powerful schema conversion toolkit that helps you transform between various schema formats including JSON Schema, JSON Structure, Avro Schema, Protocol Buffers, XSD, SQL, and many more.
+
+This package is published under two names:
+
+- **`structurize`** - The primary package name, emphasizing JSON Structure conversion capabilities
+- **`avrotize`** - The original package name, emphasizing Avro Schema conversion capabilities
+
+Both packages currently share the same features and codebase. However, in future releases, Avro-focused and JSON Structure-focused features may be split across the two tools to make the feature list more manageable and focused for users. Choose whichever variant better aligns with your primary use case.
+
+## Quick Start
+
+Install the package:
+
+```bash
+pip install structurize
+```
+
+or
+
+```bash
+pip install avrotize
+```
+
+Use the CLI:
+
+```bash
+# Using structurize
+structurize --help
+
+# Or using avrotize
+avrotize --help
+```
+
+## Key Features
+
+- Convert between JSON Schema, JSON Structure, and Avro Schema
+- Transform schemas to and from Protocol Buffers, XSD, ASN.1
+- Generate code in C#, Python, TypeScript, Java, Go, Rust, C++, JavaScript
+- Export schemas to SQL databases (MySQL, PostgreSQL, SQL Server, Oracle, Cassandra, MongoDB, DynamoDB, and more)
+- Convert to Parquet, Iceberg, Kusto, and other data formats
+- Generate documentation in Markdown
+
+## Documentation
+
+For complete documentation, examples, and detailed usage instructions, please see the main repository:
+
+**[📖 Full Documentation](https://github.com/clemensv/avrotize)**
+
+The main README includes:
+
+- Comprehensive command reference
+- Conversion examples and use cases
+- Code generation guides
+- Database schema export instructions
+- API documentation
+
+## License
+
+MIT License - see the [LICENSE](../LICENSE) file in the repository root.

{structurize-2.16.5 → structurize-2.17.0}/avrotize/__init__.py

@@ -48,6 +48,7 @@ _mappings = {
     "convert_avro_to_javascript": (f"{mod}.avrotojs", "convert_avro_to_javascript"),
     "convert_avro_schema_to_javascript": (f"{mod}.avrotojs", "convert_avro_schema_to_javascript"),
     "convert_avro_to_markdown": (f"{mod}.avrotomd", "convert_avro_to_markdown"),
+    "convert_structure_to_markdown": (f"{mod}.structuretomd", "convert_structure_to_markdown"),
     "convert_avro_to_cpp": (f"{mod}.avrotocpp", "convert_avro_to_cpp"),
     "convert_avro_schema_to_cpp": (f"{mod}.avrotocpp", "convert_avro_schema_to_cpp"),
     "convert_avro_to_go": (f"{mod}.avrotogo", "convert_avro_to_go"),

{structurize-2.16.5 → structurize-2.17.0}/avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.16.5'
-__version_tuple__ = version_tuple = (2, 16, 5)
+__version__ = version = '2.17.0'
+__version_tuple__ = version_tuple = (2, 17, 0)
 
-__commit_id__ = commit_id = 'gc44cec929'
+__commit_id__ = commit_id = 'gfbce894a4'

{structurize-2.16.5 → structurize-2.17.0}/avrotize/avrotocsharp.py

@@ -567,7 +567,7 @@ class AvroToCSharp:
         class_definition += \
             f"{INDENT}public sealed class {union_class_name}"
         if self.system_text_json_annotation:
-            class_definition += f": System.Text.Json.Serialization.JsonConverter<{union_class_name}>"
+            class_definition += f": System.Text.Json.Serialization.JsonConverter<global::{namespace}.{class_name}.{union_class_name}>"
         class_definition += f"\n{INDENT}{{\n" + \
             f"{INDENT*2}/// <summary>\n{INDENT*2}/// Default constructor\n{INDENT*2}/// </summary>\n" + \
             f"{INDENT*2}public {union_class_name}() {{ }}\n"
@@ -602,7 +602,7 @@ class AvroToCSharp:
         if self.system_text_json_annotation:
             class_definition += \
                 f"\n{INDENT*2}/// <summary>\n{INDENT*2}/// Reads the JSON representation of the object.\n{INDENT*2}/// </summary>\n" + \
-                f"{INDENT*2}public override {union_class_name}? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)\n{INDENT*2}{{\n{INDENT*3}var element = JsonElement.ParseValue(ref reader);\n" + \
+                f"{INDENT*2}public override {union_class_name}? Read(ref Utf8JsonReader reader, System.Type typeToConvert, JsonSerializerOptions options)\n{INDENT*2}{{\n{INDENT*3}var element = JsonElement.ParseValue(ref reader);\n" + \
                 class_definition_read + \
                 f"{INDENT*3}throw new NotSupportedException(\"No record type matched the JSON data\");\n{INDENT*2}}}\n" + \
                 f"\n{INDENT*2}/// <summary>\n{INDENT*2}/// Writes the JSON representation of the object.\n{INDENT*2}/// </summary>\n" + \
@@ -612,6 +612,51 @@ class AvroToCSharp:
                 f"\n{INDENT*2}/// <summary>\n{INDENT*2}/// Checks if the JSON element matches the schema\n{INDENT*2}/// </summary>\n" + \
                 f"{INDENT*2}public static bool IsJsonMatch(System.Text.Json.JsonElement element)\n{INDENT*2}{{" + \
                 f"\n{INDENT*3}return "+f"\n{INDENT*3} || ".join(list_is_json_match)+f";\n{INDENT*2}}}\n"
+        
+        # Generate Equals and GetHashCode for the union class
+        # Build list of property names for comparison
+        union_property_names = []
+        for union_type in union_types:
+            if union_type.startswith("Dictionary<"):
+                match = re.findall(r"Dictionary<(.+)\s*,\s*(.+)>", union_type)
+                union_property_names.append("Map" + pascal(match[0][1].rsplit('.', 1)[-1]))
+            elif union_type.startswith("List<"):
+                match = re.findall(r"List<(.+)>", union_type)
+                union_property_names.append("Array" + pascal(match[0].rsplit('.', 1)[-1]))
+            elif union_type == "byte[]":
+                union_property_names.append("bytes")
+            else:
+                prop_name = union_type.rsplit('.', 1)[-1]
+                if self.is_csharp_reserved_word(prop_name):
+                    prop_name = f"@{prop_name}"
+                union_property_names.append(prop_name)
+        
+        equals_conditions = " && ".join([f"Equals({name}, other.{name})" for name in union_property_names])
+        
+        # HashCode.Combine only accepts up to 8 arguments, so we need to chain calls for larger unions
+        def generate_hashcode_expression(props: list) -> str:
+            if len(props) <= 8:
+                return f"HashCode.Combine({', '.join(props)})"
+            else:
+                # Chain HashCode.Combine calls: Combine(Combine(first 7...), next 7...)
+                first_batch = props[:7]
+                remaining = props[7:]
+                inner = generate_hashcode_expression(remaining)
+                return f"HashCode.Combine({', '.join(first_batch)}, {inner})"
+        
+        hashcode_expression = generate_hashcode_expression(union_property_names)
+        
+        class_definition += \
+            f"\n{INDENT*2}/// <summary>\n{INDENT*2}/// Determines whether the specified object is equal to the current object.\n{INDENT*2}/// </summary>\n" + \
+            f"{INDENT*2}public override bool Equals(object? obj)\n{INDENT*2}{{\n" + \
+            f"{INDENT*3}if (obj is not {union_class_name} other) return false;\n" + \
+            f"{INDENT*3}return {equals_conditions};\n" + \
+            f"{INDENT*2}}}\n" + \
+            f"\n{INDENT*2}/// <summary>\n{INDENT*2}/// Serves as the default hash function.\n{INDENT*2}/// </summary>\n" + \
+            f"{INDENT*2}public override int GetHashCode()\n{INDENT*2}{{\n" + \
+            f"{INDENT*3}return {hashcode_expression};\n" + \
+            f"{INDENT*2}}}\n"
+        
         class_definition += f"{INDENT}}}\n}}"
 
         if write_file:
@@ -628,26 +673,34 @@ class AvroToCSharp:
                 if found:
                     return found
         elif isinstance(avro_schema, dict):
-            if avro_schema['type'] == kind and avro_schema['name'] == type_name and avro_schema.get('namespace', parent_namespace) == type_namespace:
+            if avro_schema.get('type') == kind and avro_schema.get('name') == type_name and avro_schema.get('namespace', parent_namespace) == type_namespace:
                 return avro_schema
             parent_namespace = avro_schema.get('namespace', parent_namespace)
             if 'fields' in avro_schema and isinstance(avro_schema['fields'], list):
                 for field in avro_schema['fields']:
-                    if isinstance(field,dict) and 'type' in field and isinstance(field['type'], dict):
-                        return self.find_type(kind, field['type'], type_name, type_namespace, parent_namespace)
+                    if isinstance(field, dict) and 'type' in field:
+                        # Recursively search within field types (including union arrays)
+                        found = self.find_type(kind, field['type'], type_name, type_namespace, parent_namespace)
+                        if found:
+                            return found
         return None
 
     def is_enum_type(self, avro_type: Union[str, Dict, List]) -> bool:
-        """ Checks if a type is an enum """
+        """ Checks if a type is an enum (including nullable enums) """
         if isinstance(avro_type, str):
             schema = self.schema_doc
             name = avro_type.split('.')[-1]
             namespace = ".".join(avro_type.split('.')[:-1])
             return self.find_type('enum', schema, name, namespace) is not None
         elif isinstance(avro_type, list):
+            # Check for nullable enum: ["null", <enum-type>] or [<enum-type>, "null"]
+            non_null_types = [t for t in avro_type if t != 'null']
+            if len(non_null_types) == 1:
+                return self.is_enum_type(non_null_types[0])
             return False
         elif isinstance(avro_type, dict):
-            return avro_type['type'] == 'enum'
+            return avro_type.get('type') == 'enum'
+        return False
 
     def generate_property(self, field: Dict, class_name: str, parent_namespace: str) -> str:
         """ Generates a property """
@@ -686,7 +739,15 @@ class AvroToCSharp:
         initialization = ""
         if field_default is not None:
             # Has explicit default value
-            initialization = " = " + (f"\"{field_default}\"" if isinstance(field_default, str) else str(field_default)) + ";"
+            if is_enum_type:
+                # For enum types, use qualified enum value (e.g., Type.Circle)
+                # Get the base enum type name (strip nullable ? suffix if present)
+                enum_type = field_type.rstrip('?')
+                initialization = f" = {enum_type}.{field_default};"
+            elif isinstance(field_default, str):
+                initialization = f" = \"{field_default}\";"
+            else:
+                initialization = f" = {field_default};"
         elif field_type == "string":
             # Non-nullable string without default should be initialized to empty string
             initialization = " = string.Empty;"
@@ -786,12 +847,13 @@ class AvroToCSharp:
         """ Retrieves fields for a given class name """
 
         class Field:
-            def __init__(self, fn: str, ft:str, tv:Any, ct: bool, pm: bool):
+            def __init__(self, fn: str, ft:str, tv:Any, ct: bool, pm: bool, ie: bool):
                 self.field_name = fn
                 self.field_type = ft
                 self.test_value = tv
                 self.is_const = ct
                 self.is_primitive = pm
+                self.is_enum = ie
 
         fields: List[Field] = []
         if avro_schema and 'fields' in avro_schema:
@@ -805,11 +867,13 @@ class AvroToCSharp:
                     field_name = f"@{field_name}"
                 field_type = self.convert_avro_type_to_csharp(class_name, field_name, field['type'], str(avro_schema.get('namespace', '')))
                 is_class = field_type in self.generated_types and self.generated_types[field_type] == "class"
+                is_enum = self.is_enum_type(field['type'])
                 f = Field(field_name,
                           field_type,
                           (self.get_test_value(field_type) if not "const" in field else '\"'+str(field["const"])+'\"'),
                           "const" in field and field["const"] is not None,
-                          not is_class)
+                          not is_class,
+                          is_enum)
                 fields.append(f)
         return cast(List[Any], fields)