structurize 2.16.2__py3-none-any.whl → 2.16.5__py3-none-any.whl

avrotize/avrotomd.py

@@ -1,137 +1,137 @@
-# coding: utf-8
-"""
-Module to convert Avro schema to a comprehensive README.md.
-"""
-
-import json
-import os
-from jinja2 import Environment, FileSystemLoader
-
-from avrotize.common import render_template
-
-class AvroToMarkdownConverter:
-    """
-    Class to convert Avro schema to a comprehensive README.md.
-    """
-
-    def __init__(self, avro_schema_path, markdown_path):
-        """
-        Initialize the converter with file paths.
-
-        :param avro_schema_path: Path to the Avro schema file.
-        :param markdown_path: Path to save the README.md file.
-        """
-        self.avro_schema_path = avro_schema_path
-        self.markdown_path = markdown_path
-        self.records = {}
-        self.enums = {}
-        self.fixeds = {}
-
-    def convert(self):
-        """
-        Convert Avro schema to Markdown and save to file.
-        """
-        with open(self.avro_schema_path, 'r', encoding='utf-8') as file:
-            avro_schemas = json.load(file)
-
-        schema_name = os.path.splitext(os.path.basename(self.avro_schema_path))[0]
-        if isinstance(avro_schemas, dict):
-            self.extract_named_types(avro_schemas)
-        elif isinstance(avro_schemas, list):
-            for schema in avro_schemas:
-                self.extract_named_types(schema)
-
-        self.generate_markdown(schema_name)
-
-    def extract_named_types(self, schema, parent_namespace: str = ''):
-        """
-        Extract all named types (records, enums, fixed) from the schema.
-        """
-        
-        if isinstance(schema, dict):
-            ns = schema.get('namespace', parent_namespace)
-            if schema['type'] == 'record':
-                self.records.setdefault(ns, []).append(schema)
-            elif schema['type'] == 'enum':
-                self.enums.setdefault(ns, []).append(schema)
-            elif schema['type'] == 'fixed':
-                self.fixeds.setdefault(ns, []).append(schema)
-            if 'fields' in schema:
-                for field in schema['fields']:
-                    self.extract_named_types(field['type'], ns)
-            if 'items' in schema:
-                self.extract_named_types(schema['items'], ns)
-            if 'values' in schema:
-                self.extract_named_types(schema['values'], ns)
-        elif isinstance(schema, list):
-            for sub_schema in schema:
-                self.extract_named_types(sub_schema, '')
-                
-    def generate_markdown(self, schema_name: str):
-        """
-        Generate markdown content from the extracted types using Jinja2 template.
-
-        :param schema_name: The name of the schema file.
-        :return: Markdown content as a string.
-        """
-        render_template("avrotomd/README.md.jinja", self.markdown_path,
-            schema_name = schema_name,
-            records  = self.records,
-            enums = self.enums,
-            fixeds = self.fixeds,
-            generate_field_markdown = self.generate_field_markdown
-        )
-
-    def generate_field_markdown(self, field, level):
-        """
-        Generate markdown content for a single field.
-
-        :param field: Avro field as a dictionary.
-        :param level: The current level of nesting.
-        :return: Markdown content as a string.
-        """
-        field_md = []
-        heading = "#" * level
-        field_md.append(f"{heading} {field['name']}\n")
-        field_md.append(f"- **Type:** {self.get_avro_type(field['type'])}")
-        if 'doc' in field:
-            field_md.append(f"- **Description:** {field['doc']}")
-        if 'default' in field:
-            field_md.append(f"- **Default:** {field['default']}")
-        if isinstance(field['type'], dict) and field['type'].get('logicalType'):
-            field_md.append(f"- **Logical Type:** {field['type']['logicalType']}")
-        if 'symbols' in field.get('type', {}):
-            field_md.append(f"- **Symbols:** {', '.join(field['type']['symbols'])}")
-        field_md.append("\n")
-        return "\n".join(field_md)
-
-    def get_avro_type(self, avro_type):
-        """
-        Get Avro type as a string.
-
-        :param avro_type: Avro type as a string or dictionary.
-        :return: Avro type as a string.
-        """
-        if isinstance(avro_type, list):
-            return " | ".join([self.get_avro_type(t) for t in avro_type])
-        if isinstance(avro_type, dict):
-            type_name = avro_type.get('type', 'unknown')
-            namespace = avro_type.get('namespace', '')
-            if type_name in [r['name'] for r in self.records.get(namespace, [])]:
-                return f"[{type_name}](#record-{namespace.lower()}-{type_name.lower()})"
-            if type_name in [e['name'] for e in self.enums.get(namespace, [])]:
-                return f"[{type_name}](#enum-{namespace.lower()}-{type_name.lower()})"
-            if type_name in [f['name'] for f in self.fixeds.get(namespace, [])]:
-                return f"[{type_name}](#fixed-{namespace.lower()}-{type_name.lower()})"
-            return type_name
-        return avro_type
-
-def convert_avro_to_markdown(avro_schema_path, markdown_path):
-    """
-    Convert an Avro schema file to a README.md file.
-
-    :param avro_schema_path: Path to the Avro schema file.
-    :param markdown_path: Path to save the README.md file.
-    """
-    converter = AvroToMarkdownConverter(avro_schema_path, markdown_path)
-    converter.convert()
+# coding: utf-8
+"""
+Module to convert Avro schema to a comprehensive README.md.
+"""
+
+import json
+import os
+from jinja2 import Environment, FileSystemLoader
+
+from avrotize.common import render_template
+
+class AvroToMarkdownConverter:
+    """
+    Class to convert Avro schema to a comprehensive README.md.
+    """
+
+    def __init__(self, avro_schema_path, markdown_path):
+        """
+        Initialize the converter with file paths.
+
+        :param avro_schema_path: Path to the Avro schema file.
+        :param markdown_path: Path to save the README.md file.
+        """
+        self.avro_schema_path = avro_schema_path
+        self.markdown_path = markdown_path
+        self.records = {}
+        self.enums = {}
+        self.fixeds = {}
+
+    def convert(self):
+        """
+        Convert Avro schema to Markdown and save to file.
+        """
+        with open(self.avro_schema_path, 'r', encoding='utf-8') as file:
+            avro_schemas = json.load(file)
+
+        schema_name = os.path.splitext(os.path.basename(self.avro_schema_path))[0]
+        if isinstance(avro_schemas, dict):
+            self.extract_named_types(avro_schemas)
+        elif isinstance(avro_schemas, list):
+            for schema in avro_schemas:
+                self.extract_named_types(schema)
+
+        self.generate_markdown(schema_name)
+
+    def extract_named_types(self, schema, parent_namespace: str = ''):
+        """
+        Extract all named types (records, enums, fixed) from the schema.
+        """
+        
+        if isinstance(schema, dict):
+            ns = schema.get('namespace', parent_namespace)
+            if schema['type'] == 'record':
+                self.records.setdefault(ns, []).append(schema)
+            elif schema['type'] == 'enum':
+                self.enums.setdefault(ns, []).append(schema)
+            elif schema['type'] == 'fixed':
+                self.fixeds.setdefault(ns, []).append(schema)
+            if 'fields' in schema:
+                for field in schema['fields']:
+                    self.extract_named_types(field['type'], ns)
+            if 'items' in schema:
+                self.extract_named_types(schema['items'], ns)
+            if 'values' in schema:
+                self.extract_named_types(schema['values'], ns)
+        elif isinstance(schema, list):
+            for sub_schema in schema:
+                self.extract_named_types(sub_schema, '')
+                
+    def generate_markdown(self, schema_name: str):
+        """
+        Generate markdown content from the extracted types using Jinja2 template.
+
+        :param schema_name: The name of the schema file.
+        :return: Markdown content as a string.
+        """
+        render_template("avrotomd/README.md.jinja", self.markdown_path,
+            schema_name = schema_name,
+            records  = self.records,
+            enums = self.enums,
+            fixeds = self.fixeds,
+            generate_field_markdown = self.generate_field_markdown
+        )
+
+    def generate_field_markdown(self, field, level):
+        """
+        Generate markdown content for a single field.
+
+        :param field: Avro field as a dictionary.
+        :param level: The current level of nesting.
+        :return: Markdown content as a string.
+        """
+        field_md = []
+        heading = "#" * level
+        field_md.append(f"{heading} {field['name']}\n")
+        field_md.append(f"- **Type:** {self.get_avro_type(field['type'])}")
+        if 'doc' in field:
+            field_md.append(f"- **Description:** {field['doc']}")
+        if 'default' in field:
+            field_md.append(f"- **Default:** {field['default']}")
+        if isinstance(field['type'], dict) and field['type'].get('logicalType'):
+            field_md.append(f"- **Logical Type:** {field['type']['logicalType']}")
+        if 'symbols' in field.get('type', {}):
+            field_md.append(f"- **Symbols:** {', '.join(field['type']['symbols'])}")
+        field_md.append("\n")
+        return "\n".join(field_md)
+
+    def get_avro_type(self, avro_type):
+        """
+        Get Avro type as a string.
+
+        :param avro_type: Avro type as a string or dictionary.
+        :return: Avro type as a string.
+        """
+        if isinstance(avro_type, list):
+            return " | ".join([self.get_avro_type(t) for t in avro_type])
+        if isinstance(avro_type, dict):
+            type_name = avro_type.get('type', 'unknown')
+            namespace = avro_type.get('namespace', '')
+            if type_name in [r['name'] for r in self.records.get(namespace, [])]:
+                return f"[{type_name}](#record-{namespace.lower()}-{type_name.lower()})"
+            if type_name in [e['name'] for e in self.enums.get(namespace, [])]:
+                return f"[{type_name}](#enum-{namespace.lower()}-{type_name.lower()})"
+            if type_name in [f['name'] for f in self.fixeds.get(namespace, [])]:
+                return f"[{type_name}](#fixed-{namespace.lower()}-{type_name.lower()})"
+            return type_name
+        return avro_type
+
+def convert_avro_to_markdown(avro_schema_path, markdown_path):
+    """
+    Convert an Avro schema file to a README.md file.
+
+    :param avro_schema_path: Path to the Avro schema file.
+    :param markdown_path: Path to save the README.md file.
+    """
+    converter = AvroToMarkdownConverter(avro_schema_path, markdown_path)
+    converter.convert()

avrotize/avrotools.py

@@ -1,168 +1,168 @@
-""" Avro Tools Module """
-
-import json
-import hashlib
-import base64
-from typing import Dict, List, cast
-
-JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | int | bool | None
-
-def transform_to_pcf(schema_json: str) -> str:
-    """
-    Transforms an Avro schema into its Parsing Canonical Form (PCF).
-    
-    :param schema_json: The Avro schema as a JSON string.
-    :return: The Parsing Canonical Form (PCF) as a JSON string.
-    """
-    schema = json.loads(schema_json)
-    canonical_schema = canonicalize_schema(schema)
-    return json.dumps(canonical_schema, separators=(',', ':'))
-
-def avsc_to_pcf(schema_file: str) -> None:
-    """ Convert an Avro schema file to its Parsing Canonical Form (PCF)."""
-    with open(schema_file, 'r', encoding='utf-8') as file:
-        schema = json.load(file)
-        print(transform_to_pcf(json.dumps(schema)))
-
-def canonicalize_schema(schema: JsonNode, namespace:str="") -> JsonNode:
-    """
-    Recursively processes the schema to convert it to the Parsing Canonical Form (PCF).
-    
-    :param schema: The Avro schema as a dictionary.
-    :param namespace: The current namespace for resolving names.
-    :return: The canonicalized schema as a dictionary.
-    """
-    if isinstance(schema, str):
-        return schema
-    elif isinstance(schema, dict):
-        if 'type' in schema and isinstance(schema['type'], str):
-            if schema['type'] in PRIMITIVE_TYPES:
-                return schema['type']
-            if '.' not in schema['type'] and namespace:
-                schema['type'] = namespace + '.' + schema['type']
-        
-        if 'name' in schema and '.' not in cast(str,schema['name']) and namespace:
-            schema['name'] = namespace + '.' + cast(str,schema['name'])
-
-        canonical = {}
-        for field in FIELD_ORDER:
-            if field in schema:
-                value = schema[field]
-                if field == 'fields' and isinstance(value, list):
-                    value = [canonicalize_schema(f, cast(str,schema.get('namespace', namespace))) for f in value]
-                elif field == 'symbols' or field == 'items' or field == 'values':
-                    value = canonicalize_schema(value, namespace)
-                elif isinstance(value, dict):
-                    value = canonicalize_schema(value, namespace)
-                elif isinstance(value, list):
-                    value = [canonicalize_schema(v, namespace) for v in value]
-                elif isinstance(value, str):
-                    value = normalize_string(value)
-                elif isinstance(value, int):
-                    value = normalize_integer(value)
-                canonical[field] = value
-        return canonical
-    elif isinstance(schema, list):
-        return [canonicalize_schema(s, namespace) for s in schema]
-    raise ValueError("Invalid schema: " + str(schema))
-
-def normalize_string(value):
-    """
-    Normalizes JSON string literals by replacing escaped characters with their UTF-8 equivalents.
-    
-    :param value: The string value to normalize.
-    :return: The normalized string.
-    """
-    return value.encode('utf-8').decode('unicode_escape')
-
-def normalize_integer(value):
-    """
-    Normalizes JSON integer literals by removing leading zeros.
-    
-    :param value: The integer value to normalize.
-    :return: The normalized integer.
-    """
-    return int(value)
-
-def fingerprint_sha256(schema_json):
-    """
-    Generates a SHA-256 fingerprint for the given Avro schema.
-    
-    :param schema_json: The Avro schema as a JSON string.
-    :return: The SHA-256 fingerprint as a base64 string.
-    """
-    pcf = transform_to_pcf(schema_json)
-    sha256_hash = hashlib.sha256(pcf.encode('utf-8')).digest()
-    return base64.b64encode(sha256_hash).decode('utf-8')
-
-def fingerprint_md5(schema_json):
-    """
-    Generates an MD5 fingerprint for the given Avro schema.
-    
-    :param schema_json: The Avro schema as a JSON string.
-    :return: The MD5 fingerprint as a base64 string.
-    """
-    pcf = transform_to_pcf(schema_json)
-    md5_hash = hashlib.md5(pcf.encode('utf-8')).digest()
-    return base64.b64encode(md5_hash).decode('utf-8')
-
-def fingerprint_rabin(schema_json):
-    """
-    Generates a 64-bit Rabin fingerprint for the given Avro schema.
-    
-    :param schema_json: The Avro schema as a JSON string.
-    :return: The Rabin fingerprint as a base64 string.
-    """
-    pcf = transform_to_pcf(schema_json).encode('utf-8')
-    fp = fingerprint64(pcf)
-    return base64.b64encode(fp.to_bytes(8, 'big')).decode('utf-8')
-
-def fingerprint64(buf):
-    """
-    Computes a 64-bit Rabin fingerprint.
-    
-    :param buf: The input byte buffer.
-    :return: The 64-bit Rabin fingerprint.
-    """
-    if FP_TABLE is None:
-        init_fp_table()
-    fp = EMPTY
-    for byte in buf:
-        fp = (fp >> 8) ^ FP_TABLE[(fp ^ byte) & 0xff]
-    return fp
-
-def init_fp_table():
-    """
-    Initializes the fingerprint table for the Rabin fingerprint algorithm.
-    """
-    global FP_TABLE
-    FP_TABLE = []
-    for i in range(256):
-        fp = i
-        for _ in range(8):
-            fp = (fp >> 1) ^ (EMPTY & -(fp & 1))
-        FP_TABLE.append(fp)
-
-PRIMITIVE_TYPES = {"null", "boolean", "int", "long", "float", "double", "bytes", "string"}
-FIELD_ORDER = ["name", "type", "fields", "symbols", "items", "values", "size"]
-
-EMPTY = 0xc15d213aa4d7a795
-FP_TABLE = None
-
-class PCFSchemaResult:
-    def __init__(self, pcf: str, sha256: str, md5: str, rabin: str) -> None:
-        self.pcf = pcf
-        self.sha256 = sha256
-        self.md5 = md5
-        self.rabin = rabin
-
-def pcf_schema(schema_json):
-    """
-    Wrapper function to provide PCF transformation and fingerprinting.
-    
-    :param schema_json: The Avro schema as a JSON string.
-    :return: An instance of the PCFSchemaResult class containing the PCF and fingerprints (SHA-256, MD5, and Rabin) as base64 strings.
-    """
-    pcf = transform_to_pcf(schema_json)
-    return PCFSchemaResult(pcf, fingerprint_sha256(schema_json), fingerprint_md5(schema_json), fingerprint_rabin(schema_json))
-
+""" Avro Tools Module """
+
+import json
+import hashlib
+import base64
+from typing import Dict, List, cast
+
+JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | int | bool | None
+
+def transform_to_pcf(schema_json: str) -> str:
+    """
+    Transforms an Avro schema into its Parsing Canonical Form (PCF).
+    
+    :param schema_json: The Avro schema as a JSON string.
+    :return: The Parsing Canonical Form (PCF) as a JSON string.
+    """
+    schema = json.loads(schema_json)
+    canonical_schema = canonicalize_schema(schema)
+    return json.dumps(canonical_schema, separators=(',', ':'))
+
+def avsc_to_pcf(schema_file: str) -> None:
+    """ Convert an Avro schema file to its Parsing Canonical Form (PCF)."""
+    with open(schema_file, 'r', encoding='utf-8') as file:
+        schema = json.load(file)
+        print(transform_to_pcf(json.dumps(schema)))
+
+def canonicalize_schema(schema: JsonNode, namespace:str="") -> JsonNode:
+    """
+    Recursively processes the schema to convert it to the Parsing Canonical Form (PCF).
+    
+    :param schema: The Avro schema as a dictionary.
+    :param namespace: The current namespace for resolving names.
+    :return: The canonicalized schema as a dictionary.
+    """
+    if isinstance(schema, str):
+        return schema
+    elif isinstance(schema, dict):
+        if 'type' in schema and isinstance(schema['type'], str):
+            if schema['type'] in PRIMITIVE_TYPES:
+                return schema['type']
+            if '.' not in schema['type'] and namespace:
+                schema['type'] = namespace + '.' + schema['type']
+        
+        if 'name' in schema and '.' not in cast(str,schema['name']) and namespace:
+            schema['name'] = namespace + '.' + cast(str,schema['name'])
+
+        canonical = {}
+        for field in FIELD_ORDER:
+            if field in schema:
+                value = schema[field]
+                if field == 'fields' and isinstance(value, list):
+                    value = [canonicalize_schema(f, cast(str,schema.get('namespace', namespace))) for f in value]
+                elif field == 'symbols' or field == 'items' or field == 'values':
+                    value = canonicalize_schema(value, namespace)
+                elif isinstance(value, dict):
+                    value = canonicalize_schema(value, namespace)
+                elif isinstance(value, list):
+                    value = [canonicalize_schema(v, namespace) for v in value]
+                elif isinstance(value, str):
+                    value = normalize_string(value)
+                elif isinstance(value, int):
+                    value = normalize_integer(value)
+                canonical[field] = value
+        return canonical
+    elif isinstance(schema, list):
+        return [canonicalize_schema(s, namespace) for s in schema]
+    raise ValueError("Invalid schema: " + str(schema))
+
+def normalize_string(value):
+    """
+    Normalizes JSON string literals by replacing escaped characters with their UTF-8 equivalents.
+    
+    :param value: The string value to normalize.
+    :return: The normalized string.
+    """
+    return value.encode('utf-8').decode('unicode_escape')
+
+def normalize_integer(value):
+    """
+    Normalizes JSON integer literals by removing leading zeros.
+    
+    :param value: The integer value to normalize.
+    :return: The normalized integer.
+    """
+    return int(value)
+
+def fingerprint_sha256(schema_json):
+    """
+    Generates a SHA-256 fingerprint for the given Avro schema.
+    
+    :param schema_json: The Avro schema as a JSON string.
+    :return: The SHA-256 fingerprint as a base64 string.
+    """
+    pcf = transform_to_pcf(schema_json)
+    sha256_hash = hashlib.sha256(pcf.encode('utf-8')).digest()
+    return base64.b64encode(sha256_hash).decode('utf-8')
+
+def fingerprint_md5(schema_json):
+    """
+    Generates an MD5 fingerprint for the given Avro schema.
+    
+    :param schema_json: The Avro schema as a JSON string.
+    :return: The MD5 fingerprint as a base64 string.
+    """
+    pcf = transform_to_pcf(schema_json)
+    md5_hash = hashlib.md5(pcf.encode('utf-8')).digest()
+    return base64.b64encode(md5_hash).decode('utf-8')
+
+def fingerprint_rabin(schema_json):
+    """
+    Generates a 64-bit Rabin fingerprint for the given Avro schema.
+    
+    :param schema_json: The Avro schema as a JSON string.
+    :return: The Rabin fingerprint as a base64 string.
+    """
+    pcf = transform_to_pcf(schema_json).encode('utf-8')
+    fp = fingerprint64(pcf)
+    return base64.b64encode(fp.to_bytes(8, 'big')).decode('utf-8')
+
+def fingerprint64(buf):
+    """
+    Computes a 64-bit Rabin fingerprint.
+    
+    :param buf: The input byte buffer.
+    :return: The 64-bit Rabin fingerprint.
+    """
+    if FP_TABLE is None:
+        init_fp_table()
+    fp = EMPTY
+    for byte in buf:
+        fp = (fp >> 8) ^ FP_TABLE[(fp ^ byte) & 0xff]
+    return fp
+
+def init_fp_table():
+    """
+    Initializes the fingerprint table for the Rabin fingerprint algorithm.
+    """
+    global FP_TABLE
+    FP_TABLE = []
+    for i in range(256):
+        fp = i
+        for _ in range(8):
+            fp = (fp >> 1) ^ (EMPTY & -(fp & 1))
+        FP_TABLE.append(fp)
+
+PRIMITIVE_TYPES = {"null", "boolean", "int", "long", "float", "double", "bytes", "string"}
+FIELD_ORDER = ["name", "type", "fields", "symbols", "items", "values", "size"]
+
+EMPTY = 0xc15d213aa4d7a795
+FP_TABLE = None
+
+class PCFSchemaResult:
+    def __init__(self, pcf: str, sha256: str, md5: str, rabin: str) -> None:
+        self.pcf = pcf
+        self.sha256 = sha256
+        self.md5 = md5
+        self.rabin = rabin
+
+def pcf_schema(schema_json):
+    """
+    Wrapper function to provide PCF transformation and fingerprinting.
+    
+    :param schema_json: The Avro schema as a JSON string.
+    :return: An instance of the PCFSchemaResult class containing the PCF and fingerprints (SHA-256, MD5, and Rabin) as base64 strings.
+    """
+    pcf = transform_to_pcf(schema_json)
+    return PCFSchemaResult(pcf, fingerprint_sha256(schema_json), fingerprint_md5(schema_json), fingerprint_rabin(schema_json))
+