structurize 2.22.2__tar.gz

structurize-2.22.2/.gitignore

@@ -0,0 +1,15 @@
+# Copied source directory for building
+avrotize/
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Backup files
+*.bak

structurize-2.22.2/LICENSE

@@ -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 2018 CloudEvents Authors
+
+   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.

structurize-2.22.2/MANIFEST.in

@@ -0,0 +1,6 @@
+graft ../avrotize
+include ../README.md
+include ../LICENSE
+include ../MANIFEST.in
+global-exclude __pycache__
+global-exclude *.py[co]

structurize-2.22.2/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: structurize
+Version: 2.22.2
+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.22.2/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.22.2/avrotize/__init__.py

@@ -0,0 +1,66 @@
+import importlib
+
+mod = "avrotize"
+class LazyLoader:
+    """    
+    Lazy loader for the avrotize functions to speed up startup time.    
+    """
+    def __init__(self, mappings):
+        self._modules = {}
+        self._mappings = mappings
+
+    def _load_module(self, module_name):
+        if module_name not in self._modules:
+            self._modules[module_name] = importlib.import_module(module_name)
+        return self._modules[module_name]
+
+    def __getattr__(self, item):
+        if item in self._mappings:
+            module_name, func_name = self._mappings[item]
+            module = self._load_module(module_name)
+            return getattr(module, func_name)
+        else:
+            return self._load_module(f"{mod}.{item}")
+
+# Define the functions and their corresponding module paths
+_mappings = {
+    "convert_proto_to_avro": (f"{mod}.prototoavro", "convert_proto_to_avro"),
+    "convert_jsons_to_avro": (f"{mod}.jsonstoavro", "convert_jsons_to_avro"),
+    "convert_kafka_struct_to_avro_schema": (f"{mod}.kstructtoavro", "convert_kafka_struct_to_avro_schema"),
+    "convert_kusto_to_avro": (f"{mod}.kustotoavro", "convert_kusto_to_avro"),
+    "convert_asn1_to_avro": (f"{mod}.asn1toavro", "convert_asn1_to_avro"),
+    "convert_xsd_to_avro": (f"{mod}.xsdtoavro", "convert_xsd_to_avro"),
+    "convert_avro_to_json_schema": (f"{mod}.avrotojsons", "convert_avro_to_json_schema"),
+    "convert_avro_to_kusto_file": (f"{mod}.avrotokusto", "convert_avro_to_kusto_file"),
+    "convert_avro_to_kusto_db": (f"{mod}.avrotokusto", "convert_avro_to_kusto_db"),
+    "convert_avro_to_parquet": (f"{mod}.avrotoparquet", "convert_avro_to_parquet"),
+    "convert_avro_to_proto": (f"{mod}.avrotoproto", "convert_avro_to_proto"),
+    "convert_avro_to_sql": (f"{mod}.avrotodb", "convert_avro_to_sql"),
+    "convert_avro_to_xsd": (f"{mod}.avrotoxsd", "convert_avro_to_xsd"),
+    "convert_avro_to_java": (f"{mod}.avrotojava", "convert_avro_to_java"),
+    "convert_avro_schema_to_java": (f"{mod}.avrotojava", "convert_avro_schema_to_java"),
+    "convert_avro_to_csharp": (f"{mod}.avrotocsharp", "convert_avro_to_csharp"),
+    "convert_avro_schema_to_csharp": (f"{mod}.avrotocsharp", "convert_avro_schema_to_csharp"),
+    "convert_avro_to_python": (f"{mod}.avrotopython", "convert_avro_to_python"),
+    "convert_avro_schema_to_python": (f"{mod}.avrotopython", "convert_avro_schema_to_python"),
+    "convert_avro_to_typescript": (f"{mod}.avrotots", "convert_avro_to_typescript"),
+    "convert_avro_schema_to_typescript": (f"{mod}.avrotots", "convert_avro_schema_to_typescript"),
+    "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"),
+    "convert_avro_schema_to_go": (f"{mod}.avrotogo", "convert_avro_schema_to_go"),
+    "convert_avro_to_rust": (f"{mod}.avrotorust", "convert_avro_to_rust"),
+    "convert_avro_schema_to_rust": (f"{mod}.avrotorust", "convert_avro_schema_to_rust"),
+    "convert_avro_to_datapackage": (f"{mod}.avrotodatapackage", "convert_avro_to_datapackage"),
+    "convert_structure_to_javascript": (f"{mod}.structuretojs", "convert_structure_to_javascript"),
+    "convert_structure_schema_to_javascript": (f"{mod}.structuretojs", "convert_structure_schema_to_javascript"),
+}
+
+_lazy_loader = LazyLoader(_mappings)
+
+def __getattr__(name):
+    return getattr(_lazy_loader, name)

structurize-2.22.2/avrotize/__main__.py

@@ -0,0 +1,6 @@
+# __main__.py 
+
+from . import avrotize
+
+if __name__ == '__main__':
+      avrotize.main()

structurize-2.22.2/avrotize/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '2.22.2'
+__version_tuple__ = version_tuple = (2, 22, 2)
+
+__commit_id__ = commit_id = 'g25efcf5da'

structurize-2.22.2/avrotize/asn1toavro.py

@@ -0,0 +1,160 @@
+import json
+from typing import List
+import asn1tools
+from asn1tools.codecs.ber import Sequence, SequenceOf, Integer, Boolean, Enumerated, OctetString, IA5String, UTF8String, Date, Real, Choice, Null, SetOf, Recursive, ExplicitTag
+from asn1tools.codecs.ber import BitString, VisibleString, BMPString, GeneralString, GraphicString, NumericString, PrintableString, TeletexString, UniversalString, ObjectIdentifier, Set
+
+from avrotize.common import avro_name
+from avrotize.dependency_resolver import sort_messages_by_dependencies
+
+def asn1_type_to_avro_type(asn1_type: dict, avro_schema: list, namespace: str, parent_type_name: str | None, parent_member_name: str | None, dependencies: list)-> str | dict | None:
+    """Convert an ASN.1 type to an Avro type."""
+    avro_type: str | dict | list | None = None
+    deps: List[str] = []
+
+    if isinstance(asn1_type,Integer):
+        avro_type = 'int'
+    elif isinstance(asn1_type, Boolean):
+        avro_type = 'boolean'
+    elif isinstance(asn1_type, Enumerated):
+        symbols = [avro_name(member) for member in asn1_type.data_to_value.keys()]
+        avro_type = { 
+            'type': 'enum', 
+            'name': avro_name(parent_member_name if parent_member_name else asn1_type.name),
+            'namespace': namespace, 
+            'symbols': symbols
+            }
+    elif isinstance(asn1_type, Sequence) or isinstance(asn1_type, Choice) or isinstance(asn1_type, Set):
+        if avro_schema and next((s for s in avro_schema if s.get('name') == asn1_type.type_name), []):
+            return namespace + '.' + asn1_type.type_name
+        else:
+            record_name = asn1_type.type_name if asn1_type.type_name else asn1_type.name
+            if record_name == 'CHOICE' or record_name == 'SEQUENCE' or record_name == 'SET':
+                if parent_member_name and parent_type_name:
+                    record_name = parent_type_name + parent_member_name         
+                elif parent_type_name:
+                    record_name = parent_type_name 
+                else:
+                    raise ValueError(f"Can't name record without a type name and member name")      
+
+            fields = []
+            for member in asn1_type.members if isinstance(asn1_type, Choice) else asn1_type.root_members:
+                field_type = asn1_type_to_avro_type(member, avro_schema, namespace, record_name, member.name, deps)
+                if isinstance(field_type, dict) and (field_type.get('type') == 'record' or field_type.get('type') == 'enum'):
+                    existing_type = next((t for t in avro_schema if (isinstance(t,dict) and t.get('name') == field_type['name'] and t.get('namespace') == field_type.get('namespace')) ), None)
+                    if not existing_type:
+                        field_type['dependencies'] = [dep for dep in deps if dep != field_type['namespace']+'.'+field_type['name']]
+                        avro_schema.append(field_type)
+                    field_type = namespace + '.' + field_type.get('name','')
+                    dependencies.append(field_type)
+                if isinstance(asn1_type, Choice):
+                    field_type = [field_type, 'null']
+                fields.append({
+                    'name': avro_name(member.name),
+                    'type': field_type
+                })
+            
+            avro_type = {
+                'type': 'record', 
+                'name': avro_name(record_name),
+                'namespace': namespace,
+                'fields': fields
+                }
+    elif isinstance(asn1_type, BitString):
+        avro_type = {
+            'type': 'bytes',
+            'logicalType': 'bitstring'
+        }
+    elif isinstance(asn1_type, ObjectIdentifier):
+        avro_type = 'string'
+    elif isinstance(asn1_type, SequenceOf):
+        record_name = asn1_type.name if asn1_type.name else parent_member_name
+        if record_name == 'SEQUENCE OF':
+            record_name = parent_member_name if parent_member_name else ''
+        if parent_type_name:
+            record_name = parent_type_name + record_name
+        item_type = asn1_type_to_avro_type(asn1_type.element_type, avro_schema, namespace, record_name, 'Item', deps)
+        if isinstance(item_type, dict) and not item_type.get('name'):
+            item_type['name'] = asn1_type.name + 'Item'
+        avro_type = {
+            'type': 'array',
+            'namespace': namespace, 
+            'name': avro_name(record_name), 
+            'items': item_type
+            }
+    elif isinstance(asn1_type, SetOf):
+        record_name = asn1_type.name if asn1_type.name else parent_member_name
+        if record_name == 'SET OF':
+            record_name = parent_member_name if parent_member_name else ''                
+        if parent_type_name:
+            record_name = parent_type_name + record_name
+        item_type = asn1_type_to_avro_type(asn1_type.element_type, avro_schema, namespace, record_name, 'Item', deps)
+        if isinstance(item_type, dict) and not item_type.get('name'):
+            item_type['name'] = asn1_type.name + 'Item'               
+        avro_type = {
+            'type': 'array',
+            'namespace': namespace, 
+            'name': avro_name(record_name),
+            'items': item_type
+            }
+    elif isinstance(asn1_type, OctetString):
+        avro_type = 'bytes'
+    elif isinstance(asn1_type, IA5String) or isinstance(asn1_type, UTF8String) or isinstance(asn1_type, VisibleString) or isinstance(asn1_type, BMPString) or isinstance(asn1_type, GeneralString) or isinstance(asn1_type, GraphicString) or isinstance(asn1_type, NumericString) or isinstance(asn1_type, PrintableString) or isinstance(asn1_type, TeletexString) or isinstance(asn1_type, UniversalString):
+        avro_type = 'string'
+    elif isinstance(asn1_type, Date):
+        avro_type = {'type': 'int', 'logicalType': 'date'}
+    elif isinstance(asn1_type, Real):
+        avro_type = 'double'
+    elif isinstance(asn1_type, Null):
+        avro_type = 'null'
+    elif isinstance(asn1_type, Recursive):
+        avro_type = asn1_type.type_name
+    elif isinstance(asn1_type, ExplicitTag):
+        avro_type = asn1_type_to_avro_type(asn1_type.inner, avro_schema, namespace, parent_type_name, parent_member_name, dependencies)
+        if isinstance(avro_type, dict):
+            avro_type['name'] = asn1_type.name if asn1_type.name else asn1_type.type_name
+    else:
+        raise ValueError(f"Don't know how to translate ASN.1 type '{type(asn1_type)}' to Avro")
+
+    if len(avro_schema) > 0 and isinstance(avro_type, dict) and 'name' in avro_type:
+        existing_type = next((t for t in avro_schema if (isinstance(t,dict) and t.get('name') == avro_type['name'] and t.get('namespace') == avro_type.get('namespace')) ), None)
+        if existing_type:
+            qualified_name = namespace + '.' + existing_type.get('name','')
+            dependencies.append(qualified_name)
+            return qualified_name
+            
+    return avro_type
+
+def convert_asn1_to_avro_schema(asn1_spec_list: List[str]):
+    """Convert ASN.1 specification to Avro schema."""
+    
+    try:
+        spec = asn1tools.compile_files(asn1_spec_list)
+    except asn1tools.ParseError as e:
+        print(f"Error parsing ASN.1 files: {e.args[0]}")
+        for file in asn1_spec_list:
+            print(f"  {file}")
+        return None
+    
+    avro_schema: List[dict] = []
+    for module_name, module in spec.modules.items():
+        for type_name, asn1_type in module.items():
+            dependencies: List [str] = []
+            avro_type = asn1_type_to_avro_type(asn1_type.type, avro_schema, avro_name(module_name), type_name, None, dependencies)
+            if avro_type and not isinstance(avro_type, str):
+                avro_type['dependencies'] = [dep for dep in dependencies if dep != avro_type['namespace'] + '.' + avro_type['name']]
+                avro_schema.append(avro_type)
+    
+    avro_schema = sort_messages_by_dependencies(avro_schema)
+
+    if len(avro_schema) == 1:
+        return avro_schema[0]
+    return avro_schema
+
+def convert_asn1_to_avro(asn1_spec_list: List[str], avro_file_path: str):
+    """Convert ASN.1 specification to Avro schema and save it to a file."""
+    avro_schema = convert_asn1_to_avro_schema(asn1_spec_list)
+    if avro_schema is None:
+        return
+    with open(avro_file_path, 'w') as file:
+        json.dump(avro_schema, file, indent=4)