structurize 2.19.0__py3-none-any.whl

avrotize/xsdtoavro.py

@@ -0,0 +1,413 @@
+# pylint: disable=line-too-long, consider-iterating-dictionary, too-many-locals, too-many-branches
+
+"""Converts XSD to Avro schema."""
+
+import os
+import re
+from typing import Dict, List, Tuple
+import xml.etree.ElementTree as ET
+import json
+from urllib.parse import urlparse
+from avrotize.common import avro_namespace, generic_type
+
+from avrotize.dependency_resolver import inline_dependencies_of, sort_messages_by_dependencies
+
+XSD_NAMESPACE = 'http://www.w3.org/2001/XMLSchema'
+
+
+class XSDToAvro:
+    """ Convert XSD to Avro schema."""
+
+    def __init__(self) -> None:
+        """ Initialize the class. """
+        self.simple_type_map: Dict[str, str | dict] = {}
+        self.avro_namespace = ''
+        self.xml_namespace = ''
+
+    def xsd_targetnamespace_to_avro_namespace(self, targetnamespace: str) -> str:
+        """Convert a XSD namespace to Avro Namespace."""
+        parsed_url = urlparse(targetnamespace)
+        if parsed_url.scheme == 'urn':
+            path_segments = parsed_url.path.strip(
+                ':').replace('.', '-').split(':')
+            # join all path segments that start with a number with the previous one
+            new_path_segments: List[str] = []
+            n = len(path_segments)
+            for i in range(n):
+                if path_segments[i][0].isdigit():
+                    if i == 0:
+                        new_path_segments.append('_'+path_segments[i])
+                    else:
+                        new_path_segments[-1] = f"{new_path_segments[-1]}-{path_segments[i]}"
+                else:
+                    new_path_segments.append(path_segments[i])
+            path_segments = new_path_segments
+        else:
+            path_segments = parsed_url.path.strip('/').split('/')
+            path_segments = list(reversed(path_segments))
+        namespace_prefix = '.'.join(path_segments)
+        if parsed_url.hostname:
+            namespace_suffix = parsed_url.hostname
+            namespace = f"{namespace_prefix}.{namespace_suffix}"
+        else:
+            namespace = namespace_prefix
+        return avro_namespace(namespace)
+
+    def xsd_to_avro_type(self, xsd_type: str, namespaces: dict):
+        """Convert a XSD type to an Avro type."""
+        if xsd_type in self.simple_type_map:
+            return self.simple_type_map[xsd_type]
+
+        # split the type on the first colon
+        if ':' not in xsd_type:
+            type_name = xsd_type
+            prefix = ''
+        else:
+            prefix, type_name = xsd_type.split(':', 1)
+            if not type_name:
+                type_name = prefix
+                prefix = ''
+        # find the namespace for the prefix
+        ns = namespaces.get(XSD_NAMESPACE, '')
+        if ns == prefix:
+            base_type_map = {
+                'string': 'string',
+                'int': 'int',
+                'integer': 'int',
+                'long': 'long',
+                'short': 'int',
+                'decimal': {'type': 'bytes', 'logicalType': 'decimal', 'precision': 32, 'scale': 6},
+                'float': 'float',
+                'double': 'double',
+                'boolean': 'boolean',
+                'byte': 'int',
+                'date': {'type': 'int', 'logicalType': 'date'},
+                'dateTime': {'type': 'long', 'logicalType': 'timestamp-millis'},
+                'time': {'type': 'int', 'logicalType': 'time-millis'},
+                'duration': {'type': 'int', 'logicalType': 'duration'},
+                'gYear': {'type': 'string'},
+                'gYearMonth': {'type': 'string'},
+                'gMonth': {'type': 'string'},
+                'gMonthDay': {'type': 'string'},
+                'gDay': {'type': 'string'},
+                'nonNegativeInteger': 'int',
+                'positiveInteger': 'int',
+                'unsignedInt': 'int',
+                'unsignedShort': 'int',
+                'unsignedByte': 'int',
+                'unsignedLong': 'long',
+                'yearMonthDuration': {'type': 'string', 'logicalType': 'duration'},
+                'dayTimeDuration': {'type': 'string', 'logicalType': 'duration'},
+                'dateTimeStamp': {'type': 'long', 'logicalType': 'timestamp-millis'},
+                'hexBinary': 'bytes',
+                'base64Binary': 'bytes',
+                'anyURI': 'string',
+                'normalizedString': 'string',
+                'token': 'string',
+                'language': 'string',
+                'Name': 'string',
+                'NCName': 'string',
+                'ENTITY': 'string',
+                'ENTITIES': 'string',
+                'ID': 'string',
+                'IDREF': 'string',
+                'IDREFS': 'string',
+                'NMTOKEN': 'string',
+                'NMTOKENS': 'string',
+                'QName': 'string',
+                'NOTATION': 'string'
+            }
+            return base_type_map.get(type_name, self.avro_namespace+'.'+type_name)
+        else:
+            return self.avro_namespace+'.'+type_name
+
+    def process_element(self, element: ET.Element, namespaces: dict, dependencies: list):
+        """Process an element in the XSD schema."""
+        name = element.get('name')
+        type_value = element.get('type', '')
+        if type_value:
+            avro_type = self.xsd_to_avro_type(type_value, namespaces)
+            if not type_value.startswith(f'{namespaces[XSD_NAMESPACE]}:') and type_value not in self.simple_type_map.keys():
+                dependencies.append(avro_type if isinstance(
+                    avro_type, str) else avro_type.get('namespace')+'.'+avro_type.get('name'))
+                dependencies = list(set(dependencies))
+        else:
+            complex_type = element.find(
+                f'{{{XSD_NAMESPACE}}}complexType', namespaces)
+            if complex_type is not None:
+                complex_type.set('name', name)
+                avro_type = self.process_complex_type(complex_type, namespaces)
+            else:
+                simple_type = element.find(
+                    f'{{{XSD_NAMESPACE}}}simpleType', namespaces)
+                if simple_type is not None:
+                    add_to_schema, simple_type_type = self.process_simple_type(
+                        simple_type, namespaces)
+                    if add_to_schema:
+                        avro_type = simple_type_type
+                    else:
+                        avro_type = self.simple_type_map[name]
+                else:
+                    raise ValueError('element must have a type or complexType')
+
+        max_occurs = element.get('maxOccurs')
+        if max_occurs is not None and max_occurs != '1':
+            avro_type = {'type': 'array', 'items': avro_type}
+        min_occurs = element.get('minOccurs')
+        if min_occurs is not None and min_occurs == '0':
+            avro_type = ['null', avro_type]
+        avro_field = {'name': name, 'type': avro_type}
+        annotation = element.find(f'{{{XSD_NAMESPACE}}}annotation', namespaces)
+        if annotation is not None:
+            documentation = annotation.find(
+                f'{{{XSD_NAMESPACE}}}documentation', namespaces)
+            if documentation is not None and documentation.text is not None:
+                avro_field['doc'] = documentation.text.strip()
+        return avro_field
+
+    def process_complex_type(self, complex_type: ET.Element, namespaces: dict) -> dict | str:
+        """ Process a complex type in the XSD schema."""
+        dependencies: List[str] = []
+        avro_type: dict = {
+            'type': 'record',
+            'name': complex_type.attrib.get('name'),
+            'namespace': self.avro_namespace,
+            'fields': []
+        }
+        avro_doc = ''
+        annotation = complex_type.find(
+            f'{{{XSD_NAMESPACE}}}annotation', namespaces)
+        if annotation is not None:
+            documentation = annotation.find(
+                f'{{{XSD_NAMESPACE}}}documentation', namespaces)
+            if documentation is not None and documentation.text is not None:
+                avro_doc = documentation.text.strip()
+                avro_type['doc'] = avro_doc
+        fields = []
+        for sequence in complex_type.findall(f'{{{XSD_NAMESPACE}}}sequence', namespaces):
+            for el in sequence.findall(f'{{{XSD_NAMESPACE}}}element', namespaces):
+                field = self.process_element(el, namespaces, dependencies)
+                field['xmlkind'] = 'element'
+                fields.append(field)
+            if sequence.findall(f'{{{XSD_NAMESPACE}}}any', namespaces):
+                fields.append({"name": "any", "xmlkind": "any", "type": generic_type()})
+        for all_types in complex_type.findall(f'{{{XSD_NAMESPACE}}}all', namespaces):
+            for el in all_types.findall(f'{{{XSD_NAMESPACE}}}element', namespaces):
+                field = self.process_element(el, namespaces, dependencies)
+                field['xmlkind'] = 'element'
+                fields.append(field)
+        for choice in complex_type.findall(f'{{{XSD_NAMESPACE}}}choice', namespaces):
+            choices: list = []
+            for el in choice.findall(f'{{{XSD_NAMESPACE}}}element', namespaces):
+                deps: List[str] = []
+                choice_field = self.process_element(el, namespaces, deps)
+                choice_field['xmlkind'] = 'element'
+                choice_record = {
+                    'type': 'record',
+                    'name': f'{complex_type.attrib.get("name")}_{choice_field["name"]}',
+                    'fields': [choice_field],
+                    'namespace': self.avro_namespace
+                }
+                if avro_doc:
+                    choice_record['doc'] = avro_doc
+                choices.append(choice_record)
+                dependencies.extend(deps)
+                dependencies = list(set(dependencies))
+            choices_field = {
+                'name': f'{complex_type.attrib.get("name")}',
+                'type': choices
+            }
+            fields.append(choices_field)
+        for attribute in complex_type.findall(f'.{{{XSD_NAMESPACE}}}attribute', namespaces):
+            field = self.process_element(attribute, namespaces, dependencies)
+            field['xmlkind'] = 'attribute'
+            fields.append(field)
+        for el in complex_type.findall(f'{{{XSD_NAMESPACE}}}simpleContent', namespaces):
+            simple_content = el.find(
+                f'{{{XSD_NAMESPACE}}}extension', namespaces)
+            if simple_content is not None:
+                base_type = simple_content.attrib.get('base')
+                if base_type:
+                    fields.append(
+                        {"name": "value", "type": self.xsd_to_avro_type(base_type, namespaces)})
+                    for se in simple_content.findall(f'{{{XSD_NAMESPACE}}}attribute', namespaces):
+                        field = self.process_element(se, namespaces, dependencies)
+                        field['xmlkind'] = 'attribute'
+                        fields.append(field)
+                else:
+                    raise ValueError("No base found in simpleContent")
+
+        avro_type['fields'] = fields
+        if dependencies:
+            avro_type['dependencies'] = dependencies
+        return avro_type
+
+    def process_simple_type(self, simple_type: ET.Element, namespaces: dict) -> Tuple[bool, dict | str]:
+        """ Process a simple type in the XSD schema. """
+        type_name = simple_type.attrib.get('name')
+        if not type_name:
+            raise ValueError("SimpleType must have a name")
+        avro_doc = ''
+        annotation = simple_type.find(
+            f'{{{XSD_NAMESPACE}}}annotation', namespaces)
+        if annotation is not None:
+            documentation = annotation.find(
+                f'{{{XSD_NAMESPACE}}}documentation', namespaces)
+            if documentation is not None and documentation.text is not None:
+                avro_doc = documentation.text.strip()
+
+        for restriction in simple_type.findall(f'{{{XSD_NAMESPACE}}}restriction', namespaces):
+            base_type = restriction.get('base')
+            enums: List[str] = [el.attrib.get('value', 'Empty') for el in restriction.findall(
+                f'{{{XSD_NAMESPACE}}}enumeration', namespaces)]
+            # if any of the enum entries start with a digit, we need to prefix the entry with _
+            if enums:
+                for i, enum in enumerate(enums):
+                    if enums[i][0].isdigit():
+                        enums[i] = '_'+enum
+                enum_type = {
+                    'type': 'enum',
+                    'name': simple_type.attrib.get('name'),
+                    'namespace': self.avro_namespace,
+                    'symbols': enums
+                }
+                if avro_doc:
+                    enum_type['doc'] = avro_doc
+                return True, enum_type
+            elif base_type:
+                # if the baseType is a decimal, get the precision and scale sub-element value attributes to set the logicalType
+                if base_type == namespaces[XSD_NAMESPACE]+':'+'decimal':
+                    precision = restriction.find(
+                        f'{{{XSD_NAMESPACE}}}totalDigits', namespaces)
+                    scale = restriction.find(
+                        f'{{{XSD_NAMESPACE}}}fractionDigits', namespaces)
+                    logical_type = {
+                        'type': 'bytes',
+                        'logicalType': 'decimal',
+                        'precision': int(precision.attrib.get('value', 32)) if isinstance(precision, ET.Element) else 32,
+                        'scale': int(scale.attrib.get('value', 6)) if isinstance(scale, ET.Element) else 6,
+                    }
+                    if avro_doc:
+                        logical_type['doc'] = avro_doc
+                    self.simple_type_map[type_name] = logical_type
+                    return False, logical_type
+                else:
+                    self.simple_type_map[type_name] = self.xsd_to_avro_type(
+                        base_type, namespaces)
+                    return False, self.simple_type_map[type_name]
+        raise ValueError("No content found in simple type")
+
+    def process_top_level_element(self, element: ET.Element, namespaces: dict):
+        """ Process a top level element in the XSD schema. """
+        dependencies: List[str] = []
+        avro_type: dict = {
+            'type': 'record',
+            'name': 'Root',
+            'namespace': self.avro_namespace,
+            'xmlns': self.xml_namespace,
+            'fields': []
+        }
+        annotation = element.find(f'{{{XSD_NAMESPACE}}}annotation', namespaces)
+        if annotation is not None:
+            documentation = annotation.find(
+                f'{{{XSD_NAMESPACE}}}documentation', namespaces)
+            if documentation is not None and documentation.text is not None:
+                avro_type['doc'] = documentation.text.strip()
+
+        if 'type' in element.attrib:
+            field = self.process_element(element, namespaces, dependencies)
+            field['xmlkind'] = 'element'
+            avro_type['fields'].append(field)
+            if dependencies:
+                avro_type['dependencies'] = dependencies
+            return avro_type
+        else:
+            complex_type = element.find(
+                f'{{{XSD_NAMESPACE}}}complexType', namespaces)
+            if complex_type is None:
+                raise ValueError(
+                    'top level element must have a type or be complexType')
+            complex_type.set('name', element.get('name', ''))
+            avro_complex_type = self.process_complex_type(
+                complex_type, namespaces)
+            return avro_complex_type
+
+    def extract_xml_namespaces(self, xml_str: str):
+        """ Extract XML namespaces from an XML string."""
+        # This regex finds all xmlns:prefix="uri" declarations
+        pattern = re.compile(r'xmlns:([\w]+)="([^"]+)"')
+        namespaces = {m.group(2): m.group(1)
+                      for m in pattern.finditer(xml_str)}
+        return namespaces
+
+    def xsd_to_avro(self, xsd_path: str, code_namespace: str | None = None):
+        """ Convert XSD to Avro schema. """
+        # load the XSD file into a string
+        with open(xsd_path, 'r', encoding='utf-8') as f:
+            xsd = f.read()
+
+        namespaces = self.extract_xml_namespaces(xsd)
+        root = ET.fromstring(xsd)
+        target_namespace = root.get('targetNamespace')
+        if target_namespace is None:
+            raise ValueError('targetNamespace not found')
+        self.xml_namespace = target_namespace
+        if not code_namespace:
+            self.avro_namespace = self.xsd_targetnamespace_to_avro_namespace(target_namespace)
+        else:
+            self.avro_namespace = code_namespace
+        ET.register_namespace(namespaces[XSD_NAMESPACE], XSD_NAMESPACE)
+        avro_schema: List[dict | list | str] = []
+
+        for simple_type in root.findall(f'{{{XSD_NAMESPACE}}}simpleType', namespaces):
+            add_to_schema, simple_type_type = self.process_simple_type(
+                simple_type, namespaces)
+            # we only want to append simple types if they are not resolved to one of the base types
+            if add_to_schema:
+                avro_schema.append(simple_type_type)
+        for complex_type in root.findall(f'{{{XSD_NAMESPACE}}}complexType', namespaces):
+            avro_schema.append(self.process_complex_type(
+                complex_type, namespaces))
+
+        top_level_elements = root.findall(
+            f'{{{XSD_NAMESPACE}}}element', namespaces)
+        if len(top_level_elements) == 1:
+            record = self.process_top_level_element(
+                top_level_elements[0], namespaces)
+            inline_dependencies_of(avro_schema, record)
+            return record
+        for element in top_level_elements:
+            avro_schema.append(self.process_top_level_element(
+                element, namespaces))
+
+        avro_schema = sort_messages_by_dependencies(avro_schema)
+        if len(avro_schema) == 1:
+            return avro_schema[0]
+        else:
+            return avro_schema
+
+    def convert_xsd_to_avro(self, xsd_path: str, avro_path: str, namespace: str | None = None):
+        """Convert XSD to Avro schema and write to a file."""
+        
+        
+        avro_schema = self.xsd_to_avro(xsd_path, code_namespace=namespace)
+        with open(avro_path, 'w', encoding='utf-8') as f:
+            json.dump(avro_schema, f, indent=4)
+
+
+def convert_xsd_to_avro(xsd_path: str, avro_path: str, namespace: str | None = None):
+    """ 
+    Convert XSD to Avro schema and write to a file. 
+    
+    Params:
+    xsd_path: str - Path to the XSD file.
+    avro_path: str - Path to the Avro file.
+    namespace: str | None - Namespace of the Avro schema.    
+    """
+    
+    if not os.path.exists(xsd_path):
+        raise FileNotFoundError(f"XSD file not found at {xsd_path}")    
+    if not namespace:
+        namespace = os.path.splitext(os.path.basename(xsd_path))[0].lower().replace('-', '_')        
+    xsd_to_avro = XSDToAvro()
+    xsd_to_avro.convert_xsd_to_avro(xsd_path, avro_path, namespace)

structurize-2.19.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: structurize
+Version: 2.19.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.19.0.dist-info/RECORD

@@ -0,0 +1,70 @@
+avrotize/__init__.py,sha256=JjPSX7c686TV00J_x0Py9JwXS0aJl8vpLn81Y0ondkw,3606
+avrotize/__main__.py,sha256=5pY8dYAURcOnFRvgb6fgaOIa_SOzPLIWbU8-ZTQ0jG4,88
+avrotize/_version.py,sha256=whWmGdYhR_wJ7JC69oWgfcPaP80_UeZLbA-k7pBts8I,714
+avrotize/asn1toavro.py,sha256=QDNwfBfXMxSH-k487CA3CaGCGDzOLs4PpVbbENm5uF0,8386
+avrotize/avrotize.py,sha256=VHFpBltMVBpyt0ju3ZWW725BKjQ4Fk-nrAy8udW-X44,5713
+avrotize/avrotocpp.py,sha256=hRZV247_TDD7Sm6_8sFx-UH5SueLLx2Wg6TvAVUX0iE,25693
+avrotize/avrotocsharp.py,sha256=YpJRci_UoZ2tSpl3etsCZ_tSkn2YCwXUpnGbcxSck5M,65404
+avrotize/avrotocsv.py,sha256=PaDEW2aGRFVNLwewWhJ3OwxbKFI3PBg_mTgtT4uLMko,3689
+avrotize/avrotodatapackage.py,sha256=zSCphLvCYiBKRAUCdccsr-4JysH3PyAS6fSgwa65Tss,7259
+avrotize/avrotodb.py,sha256=5fNJgz00VMimyOl7eI0lIxlcaN_JnN0mb2Q9lzCRecw,46989
+avrotize/avrotogo.py,sha256=RnycgAuGejq00hDdsUGdMHiJX6nr0VAqNArbCkTzUMg,21880
+avrotize/avrotographql.py,sha256=i6G7xWjH_Lsn_CLiM4BCPb8OyZuCCpsYjXwXNTRMwEE,7394
+avrotize/avrotoiceberg.py,sha256=plVHGWkED1YDLcMDxL7NMdJl2f8G32hwlNWFrBLcsD8,9057
+avrotize/avrotojava.py,sha256=_G_67xi1H0Ctj9KagiCnVNETvyPicOYO8ASvz6e1XYE,131861
+avrotize/avrotojs.py,sha256=QjB6XjFnDrpZBZrrWqS0TN8fQfRXBfhHabfG73FOIo8,12249
+avrotize/avrotojsons.py,sha256=WXWniQqwcl8eU35VibDv7qJJwbiLV_yoWZ4JxiZ8mHA,21588
+avrotize/avrotojstruct.py,sha256=-Hs4Ta958bRKmOfSTzRFENABCZ6lQPSPbIBEXvOQD1M,14660
+avrotize/avrotokusto.py,sha256=D6AiRPa5uiZbqo9dqrFvAknsF5oNXgIzk8_08uZTZ2M,17636
+avrotize/avrotomd.py,sha256=WHPHnfmkI3xDNIHKZ3ReYxj6tib1eCny3JOznNSN6r8,5348
+avrotize/avrotools.py,sha256=dTbGgWQyKdSuvCf4yuoymwhYO5gX9ywPu-klIXYwKZM,6052
+avrotize/avrotoparquet.py,sha256=qm5hfia5elW1Yn4KACG8bbudLAqQSwGk3fIkTvdT5Rg,9088
+avrotize/avrotoproto.py,sha256=STqbdGjVrgKrlKXt-6dZlekW_Oq0W0StRx80St1XqIc,22486
+avrotize/avrotopython.py,sha256=sPsSLseSq-toKHnsFsYRRtGePGYospRz2mwGLep-POw,31147
+avrotize/avrotorust.py,sha256=QMIBNkFpDlH44kuQo24k5D-f0lmdhoA5b7hEbhKsnMw,22214
+avrotize/avrotots.py,sha256=EalaA9feiHMyw7lfD8rifs24LsUVigmuPOu7nPh-wUc,29002
+avrotize/avrotoxsd.py,sha256=iGQq_8kC0kfKsqvqS6s_mO-kJ8N5G8vXOwqRI_DZUxc,17744
+avrotize/cddltostructure.py,sha256=MA2c-P3CIEAxEaBX-FF299gR55xcLEV3FrfTr2QfayM,74491
+avrotize/commands.json,sha256=afZ36gTItJdtM8z-qOTOw0MazKz1WKZMztY86JUHcgU,88538
+avrotize/common.py,sha256=enqNR1I9-SbW7fNJE3w7N2R87kiN6_9Oa7VB4b2AUBc,31913
+avrotize/constants.py,sha256=SvI_WLdiESe05snUfqD_jF6UWjE_2eAzGyLeRkK2WMg,2214
+avrotize/csvtoavro.py,sha256=TuIYm_Xv8gioEHl1YgWQKOYkFGGHfuwmK5RuEAEXbt8,4293
+avrotize/datapackagetoavro.py,sha256=lw1S3H6UpKtjJj9ywDTuRw-qcihFx0vFJNPK7SlgKvY,2607
+avrotize/dependency_resolver.py,sha256=LGOTutpobJ4kMjAwvs-l0Mt2tEoZFaXCazs-u38qnYk,19374
+avrotize/dependency_version.py,sha256=tvbpO2VstTSTmNA5jbzQl48u6jnIM7BHyASQrrgsRYU,16844
+avrotize/jsonstoavro.py,sha256=ZzigsCjAxw_TflXCjTLKHTrPmkiZRZMpuaZICfT_r_I,120069
+avrotize/jsonstostructure.py,sha256=WVoKcFoDvtA_QIScZJa8oXZbwpc7Au-bTV3_pUXzTik,135445
+avrotize/jstructtoavro.py,sha256=sOq7Ru1b8_ZLCEsnBqx3gsMWd7dPAaYxoraAD0bz6rk,33891
+avrotize/kstructtoavro.py,sha256=t97JY22n0uILK3WcvQu_Yp9ONvouJRLAC2bZ3rvZ1L0,2856
+avrotize/kustotoavro.py,sha256=1oEk9mbqmP3N5-V7mBHSXpbSlYFzjJ7ajIDNJZxA1r8,21756
+avrotize/parquettoavro.py,sha256=iAPrSYNkiH3fBKNVDfIgeXkQbAiopa252ULJrGgmBDI,5531
+avrotize/proto2parser.py,sha256=__9R3cqiUJXc_efPCZZcF7rt18kA7mfhmX0qm2v0eSw,19742
+avrotize/proto3parser.py,sha256=MfE84c-oAWWuzYmKlEZ5g5LUF7YzZaASFh2trX3UCaw,15604
+avrotize/prototoavro.py,sha256=hqXBGRxYojaEbEgoHZxXwMG4R1nWC7UMl_XNLWfqH38,17346
+avrotize/structuretocddl.py,sha256=RK_dTJf0oAo6BIBM48NHRcWC96OtUjlgUC6HzXs5Lkk,21234
+avrotize/structuretocpp.py,sha256=tBWOvyZPYQ1CHN6RgDnWlmzJ1giOyQ9SlHBHWvhPyiw,35898
+avrotize/structuretocsharp.py,sha256=Y5TLMxUA0yt9QlXb8L9mSKFhLGmJkanwsg0yo0QfugI,122209
+avrotize/structuretocsv.py,sha256=w9cwXAnnakKaeTtXsLWWO8KwYnXUxyXvC7a-ZKs-E94,13851
+avrotize/structuretodatapackage.py,sha256=NEHRt30KfVDWH1EQakvuMdRZTtfVXx8fsaYud0ofb2g,29768
+avrotize/structuretodb.py,sha256=3QE_TCdNklGH5ymzGsEnX1sI4OhvX2AYKPH7xtR5tHk,43926
+avrotize/structuretogo.py,sha256=VCEUz-5J8uRqX1hWaTimtfVzEsIB-gs4wxa308rYD0s,32470
+avrotize/structuretographql.py,sha256=wcGXnrup5v5saRa1BhR6o-X8q8ujsQMVqrFHQTBPjww,20468
+avrotize/structuretoiceberg.py,sha256=itKb33Kj-7-udk4eHTLmTEasIeh1ggpZ3e_bwCxLABM,15344
+avrotize/structuretojava.py,sha256=jG2Vcf1KdezWrZo5lsecxLnmnMw1rA96uOxVWJQ4Rso,43372
+avrotize/structuretojsons.py,sha256=PJrQBaf6yQHu5eFkePxbjPBEmL-fYfX2wj6OmH1jsWw,22495
+avrotize/structuretokusto.py,sha256=rOKgYIcm7ZK8RS-VvMFPNzPzwtv7c4dIKU-fKjrJLyM,30618
+avrotize/structuretomd.py,sha256=exfCldYbieVdduhotSoLrxsbphmyJQyeQso9qv4qyUw,13642
+avrotize/structuretoproto.py,sha256=Aq0-fwMXSjjAxgZ5mq1kpo_TauigMRrJK9LNyoN-YGs,42679
+avrotize/structuretopython.py,sha256=ePlXrwbqA9r63Vw6xL-Gq3hBUScdcF9aqCQSi_xtaGo,37980
+avrotize/structuretorust.py,sha256=ChRmO7uzU-pMdDdS0Vtg-MVUaOaNhNUPwH-ZKKOHglU,35134
+avrotize/structuretots.py,sha256=PLV6W8k-yd7xkspUaQ-Vj90F26PTkB5HO0OkPJolkJ0,30800
+avrotize/structuretoxsd.py,sha256=01VpasyWSMOx04sILHLP7H-WkhGdXAEGKohUUfgrNf0,32797
+avrotize/xsdtoavro.py,sha256=nQtNH_3pEZBp67oUCPqzhvItEExHTe-8obsIfNRXt8Y,19064
+avrotize/dependencies/cpp/vcpkg/vcpkg.json,sha256=se5qnUVQ1Q6wN_DqgIioqKg_y7ouh9oly2iBAJJXkgw,414
+avrotize/dependencies/typescript/node22/package.json,sha256=qAJ_dHE0YefuIRqkuN5tsXsHWSL8u6qZGRbYwVB_zq0,388
+structurize-2.19.0.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
+structurize-2.19.0.dist-info/METADATA,sha256=9e5yUdsXaK2Vy7TPQCPfHhbzqlQfOfwxTgHoIgG7WGc,3670
+structurize-2.19.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+structurize-2.19.0.dist-info/entry_points.txt,sha256=biIH7jA5auhVqfbwHVk2gmD_gvrPYKgjpCAn0JWZ-Rs,55
+structurize-2.19.0.dist-info/top_level.txt,sha256=yn-yQ0Cm1O9fbF8KJgv4IIvX4YRGelKgPqZF1wS5P50,9
+structurize-2.19.0.dist-info/RECORD,,

structurize-2.19.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

structurize-2.19.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+structurize = avrotize.avrotize:main