structurize 3.0.2__py3-none-any.whl → 3.1.0__py3-none-any.whl

avrotize/validate.py

@@ -0,0 +1,242 @@
+"""Validates JSON instances against Avro or JSON Structure schemas.
+
+This module provides a unified interface for validating JSON data against
+both Avro schemas and JSON Structure schemas.
+"""
+
+import json
+import os
+from typing import Any, Dict, List, Tuple
+
+from avrotize.avrovalidator import AvroValidator, AvroValidationError, validate_json_against_avro
+
+# JSON Structure SDK for validation
+try:
+    from json_structure import SchemaValidator as JStructSchemaValidator
+    from json_structure import InstanceValidator as JStructInstanceValidator
+    HAS_JSTRUCT_SDK = True
+except ImportError:
+    HAS_JSTRUCT_SDK = False
+
+
+class ValidationResult:
+    """Result of validating a JSON instance against a schema."""
+
+    def __init__(self, is_valid: bool, errors: List[str] = None, instance_path: str = None):
+        self.is_valid = is_valid
+        self.errors = errors or []
+        self.instance_path = instance_path
+
+    def __str__(self) -> str:
+        if self.is_valid:
+            return f"✓ Valid" + (f": {self.instance_path}" if self.instance_path else "")
+        else:
+            prefix = f"{self.instance_path}: " if self.instance_path else ""
+            return f"✗ Invalid: {prefix}" + "; ".join(self.errors)
+
+    def __repr__(self) -> str:
+        return f"ValidationResult(is_valid={self.is_valid}, errors={self.errors})"
+
+
+def detect_schema_type(schema: Dict[str, Any]) -> str:
+    """Detects whether a schema is Avro or JSON Structure.
+
+    Args:
+        schema: The parsed schema object
+
+    Returns:
+        'avro' or 'jstruct' or 'unknown'
+    """
+    # JSON Structure schemas have $schema and $id
+    if '$schema' in schema and 'json-structure' in schema.get('$schema', ''):
+        return 'jstruct'
+
+    # Avro schemas have 'type' at root and may have 'namespace', 'fields', etc.
+    if 'type' in schema:
+        schema_type = schema.get('type')
+        # Check for Avro record, enum, array, map, or primitive
+        if schema_type in ('record', 'enum', 'fixed', 'array', 'map'):
+            return 'avro'
+        if schema_type in ('null', 'boolean', 'int', 'long', 'float', 'double', 'bytes', 'string'):
+            return 'avro'
+        # JSON Structure object type
+        if schema_type == 'object' and 'properties' in schema:
+            return 'jstruct'
+
+    # Check if it's a union (list)
+    if isinstance(schema, list):
+        return 'avro'
+
+    return 'unknown'
+
+
+def validate_instance(
+    instance: Any,
+    schema: Dict[str, Any],
+    schema_type: str = None
+) -> ValidationResult:
+    """Validates a JSON instance against a schema.
+
+    Args:
+        instance: The JSON value to validate
+        schema: The schema (Avro or JSON Structure)
+        schema_type: 'avro' or 'jstruct', auto-detected if not provided
+
+    Returns:
+        ValidationResult with validation status and any errors
+    """
+    if schema_type is None:
+        schema_type = detect_schema_type(schema)
+
+    if schema_type == 'avro':
+        errors = validate_json_against_avro(instance, schema)
+        return ValidationResult(is_valid=len(errors) == 0, errors=errors)
+
+    elif schema_type == 'jstruct':
+        if not HAS_JSTRUCT_SDK:
+            return ValidationResult(
+                is_valid=False,
+                errors=["JSON Structure SDK not installed. Install with: pip install json-structure"]
+            )
+        try:
+            validator = JStructInstanceValidator(schema)
+            errors = validator.validate(instance)
+            return ValidationResult(is_valid=len(errors) == 0, errors=errors if errors else [])
+        except Exception as e:
+            return ValidationResult(is_valid=False, errors=[str(e)])
+
+    else:
+        return ValidationResult(
+            is_valid=False,
+            errors=[f"Unknown schema type. Cannot auto-detect schema format."]
+        )
+
+
+def validate_file(
+    instance_file: str,
+    schema_file: str,
+    schema_type: str = None
+) -> List[ValidationResult]:
+    """Validates JSON instance file(s) against a schema file.
+
+    Args:
+        instance_file: Path to JSON file (single object, array, or JSONL)
+        schema_file: Path to schema file (.avsc or .jstruct.json)
+        schema_type: 'avro' or 'jstruct', auto-detected if not provided
+
+    Returns:
+        List of ValidationResult for each instance in the file
+    """
+    # Load schema
+    with open(schema_file, 'r', encoding='utf-8') as f:
+        schema = json.load(f)
+
+    # Auto-detect schema type from file extension if not provided
+    if schema_type is None:
+        if schema_file.endswith('.avsc'):
+            schema_type = 'avro'
+        elif schema_file.endswith('.jstruct.json') or schema_file.endswith('.jstruct'):
+            schema_type = 'jstruct'
+        else:
+            schema_type = detect_schema_type(schema)
+
+    # Load instances
+    with open(instance_file, 'r', encoding='utf-8') as f:
+        content = f.read().strip()
+
+    instances = []
+    instance_paths = []
+
+    # Try as JSON array or object
+    try:
+        data = json.loads(content)
+        if isinstance(data, list):
+            instances = data
+            instance_paths = [f"{instance_file}[{i}]" for i in range(len(data))]
+        else:
+            instances = [data]
+            instance_paths = [instance_file]
+    except json.JSONDecodeError:
+        # Try as JSONL
+        for i, line in enumerate(content.split('\n')):
+            line = line.strip()
+            if line:
+                try:
+                    instances.append(json.loads(line))
+                    instance_paths.append(f"{instance_file}:{i+1}")
+                except json.JSONDecodeError:
+                    pass
+
+    # Validate each instance
+    results = []
+    for instance, path in zip(instances, instance_paths):
+        result = validate_instance(instance, schema, schema_type)
+        result.instance_path = path
+        results.append(result)
+
+    return results
+
+
+def validate_json_instances(
+    input_files: List[str],
+    schema_file: str,
+    schema_type: str = None,
+    verbose: bool = False
+) -> Tuple[int, int]:
+    """Validates multiple JSON instance files against a schema.
+
+    Args:
+        input_files: List of JSON file paths to validate
+        schema_file: Path to schema file
+        schema_type: 'avro' or 'jstruct', auto-detected if not provided
+        verbose: Whether to print validation results
+
+    Returns:
+        Tuple of (valid_count, invalid_count)
+    """
+    valid_count = 0
+    invalid_count = 0
+
+    for input_file in input_files:
+        results = validate_file(input_file, schema_file, schema_type)
+        for result in results:
+            if result.is_valid:
+                valid_count += 1
+                if verbose:
+                    print(result)
+            else:
+                invalid_count += 1
+                if verbose:
+                    print(result)
+
+    return valid_count, invalid_count
+
+
+# Command entry point for avrotize CLI
+def validate(
+    input: List[str],
+    schema: str,
+    schema_type: str = None,
+    quiet: bool = False
+) -> None:
+    """Validates JSON instances against an Avro or JSON Structure schema.
+
+    Args:
+        input: List of JSON files to validate
+        schema: Path to schema file (.avsc or .jstruct.json)
+        schema_type: Schema type ('avro' or 'jstruct'), auto-detected if not provided
+        quiet: Suppress output, exit with code 0 if valid, 1 if invalid
+    """
+    valid_count, invalid_count = validate_json_instances(
+        input_files=input,
+        schema_file=schema,
+        schema_type=schema_type,
+        verbose=not quiet
+    )
+
+    if not quiet:
+        total = valid_count + invalid_count
+        print(f"\nValidation summary: {valid_count}/{total} instances valid")
+
+    if invalid_count > 0:
+        exit(1)

avrotize/xmltoschema.py

@@ -0,0 +1,122 @@
+"""Infers schema from XML files and converts to Avro or JSON Structure format.
+
+This module provides:
+- xml2a: Infer Avro schema from XML files
+- xml2s: Infer JSON Structure schema from XML files
+"""
+
+import json
+import os
+from typing import List
+
+from avrotize.schema_inference import (
+    AvroSchemaInferrer,
+    JsonStructureSchemaInferrer,
+    JsonNode
+)
+
+
+def convert_xml_to_avro(
+    input_files: List[str],
+    avro_schema_file: str,
+    type_name: str = 'Document',
+    avro_namespace: str = '',
+    sample_size: int = 0
+) -> None:
+    """Infers Avro schema from XML files.
+
+    Reads XML files, analyzes their structure, and generates an Avro schema
+    that can represent all the data. Multiple files are analyzed together to
+    produce a unified schema.
+
+    Args:
+        input_files: List of XML file paths to analyze
+        avro_schema_file: Output path for the Avro schema
+        type_name: Name for the root type
+        avro_namespace: Namespace for generated Avro types
+        sample_size: Maximum number of documents to sample (0 = all)
+    """
+    if not input_files:
+        raise ValueError("At least one input file is required")
+
+    xml_strings = _load_xml_strings(input_files, sample_size)
+
+    if not xml_strings:
+        raise ValueError("No valid XML data found in input files")
+
+    inferrer = AvroSchemaInferrer(namespace=avro_namespace)
+    schema = inferrer.infer_from_xml_values(type_name, xml_strings)
+
+    # Ensure output directory exists
+    output_dir = os.path.dirname(avro_schema_file)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    with open(avro_schema_file, 'w', encoding='utf-8') as f:
+        json.dump(schema, f, indent=2)
+
+
+def convert_xml_to_jstruct(
+    input_files: List[str],
+    jstruct_schema_file: str,
+    type_name: str = 'Document',
+    base_id: str = 'https://example.com/',
+    sample_size: int = 0
+) -> None:
+    """Infers JSON Structure schema from XML files.
+
+    Reads XML files, analyzes their structure, and generates a JSON Structure
+    schema that validates with the official JSON Structure SDK.
+
+    Args:
+        input_files: List of XML file paths to analyze
+        jstruct_schema_file: Output path for the JSON Structure schema
+        type_name: Name for the root type
+        base_id: Base URI for $id generation
+        sample_size: Maximum number of documents to sample (0 = all)
+    """
+    if not input_files:
+        raise ValueError("At least one input file is required")
+
+    xml_strings = _load_xml_strings(input_files, sample_size)
+
+    if not xml_strings:
+        raise ValueError("No valid XML data found in input files")
+
+    inferrer = JsonStructureSchemaInferrer(base_id=base_id)
+    schema = inferrer.infer_from_xml_values(type_name, xml_strings)
+
+    # Ensure output directory exists
+    output_dir = os.path.dirname(jstruct_schema_file)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    with open(jstruct_schema_file, 'w', encoding='utf-8') as f:
+        json.dump(schema, f, indent=2)
+
+
+def _load_xml_strings(input_files: List[str], sample_size: int) -> List[str]:
+    """Loads XML content from files.
+
+    Each file is treated as a single XML document.
+
+    Args:
+        input_files: List of file paths
+        sample_size: Maximum documents to load (0 = all)
+
+    Returns:
+        List of XML strings
+    """
+    xml_strings: List[str] = []
+
+    for file_path in input_files:
+        if sample_size > 0 and len(xml_strings) >= sample_size:
+            break
+
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read().strip()
+
+        if content:
+            xml_strings.append(content)
+
+    return xml_strings

{structurize-3.0.2.dist-info → structurize-3.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.0.2
+Version: 3.1.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

{structurize-3.0.2.dist-info → structurize-3.1.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 avrotize/__init__.py,sha256=t5h5wkHXr6M0mmHAB5rhjZ3Gxy9xutGTGIfojfao9rI,3820
 avrotize/__main__.py,sha256=5pY8dYAURcOnFRvgb6fgaOIa_SOzPLIWbU8-ZTQ0jG4,88
-avrotize/_version.py,sha256=oe-LtbcDFd-ELWKNVft1PeQ3Tp3QrrPnPsINIJYW4ZE,712
+avrotize/_version.py,sha256=Qp1qqaBV6Wvf5Q3U5gSPbYq0CnIECjy15DE2dH57rb8,712
 avrotize/asn1toavro.py,sha256=QDNwfBfXMxSH-k487CA3CaGCGDzOLs4PpVbbENm5uF0,8386
-avrotize/avrotize.py,sha256=VHFpBltMVBpyt0ju3ZWW725BKjQ4Fk-nrAy8udW-X44,5713
+avrotize/avrotize.py,sha256=z5snX7ZxlXwL6XC2vmhymnHvhbqIW7Tz7ZW2jRWrMgY,5966
 avrotize/avrotocpp.py,sha256=hRZV247_TDD7Sm6_8sFx-UH5SueLLx2Wg6TvAVUX0iE,25693
 avrotize/avrotocsharp.py,sha256=jOx9ctuUSsdpNDEXnNNfFHOb8zWWHclUvYTF5rInOaM,72339
 avrotize/avrotocsv.py,sha256=yqVbP4Ar8bZyEgOAmHuHAsQKfCVjIO5_pa5dtaKLZKE,4575
@@ -22,10 +22,11 @@ avrotize/avrotoparquet.py,sha256=qm5hfia5elW1Yn4KACG8bbudLAqQSwGk3fIkTvdT5Rg,908
 avrotize/avrotoproto.py,sha256=STqbdGjVrgKrlKXt-6dZlekW_Oq0W0StRx80St1XqIc,22486
 avrotize/avrotopython.py,sha256=7s73rKyaQDu5-uLnF4mK7Jat9F4jipQ-lLapPXg6aPI,34168
 avrotize/avrotorust.py,sha256=HEcDirRBCbXQNNs_FmkT-sp1dWQgZ8A23qkQYUxVuXE,24255
-avrotize/avrotots.py,sha256=u_XLjlHN0Gof5QYlpqK4X9WoX9rL30TjQMPg4TiyYnI,33241
+avrotize/avrotots.py,sha256=QBHcrJ90gCELFYL2msOrpsJA49l84JT-qPXw6dDnTIE,34404
 avrotize/avrotoxsd.py,sha256=iGQq_8kC0kfKsqvqS6s_mO-kJ8N5G8vXOwqRI_DZUxc,17744
+avrotize/avrovalidator.py,sha256=qwrjt7e97t53GK06iiY2KKv7DPnRf_2Uwv72ciom9s8,21369
 avrotize/cddltostructure.py,sha256=MA2c-P3CIEAxEaBX-FF299gR55xcLEV3FrfTr2QfayM,74491
-avrotize/commands.json,sha256=c6yV5vSey4GuoLVllPvL0Zb5rfmMQ8dgXUzKAtgKMZw,98904
+avrotize/commands.json,sha256=pqHbLdA03fVtUaDCmNK55Xu-ugA776svY-x5GZQp4gg,111680
 avrotize/common.py,sha256=enqNR1I9-SbW7fNJE3w7N2R87kiN6_9Oa7VB4b2AUBc,31913
 avrotize/constants.py,sha256=LlgHrvT6RsRPrhFGRNHmFuIj3b1bSd45yC4rBCIGGVA,2753
 avrotize/csvtoavro.py,sha256=TuIYm_Xv8gioEHl1YgWQKOYkFGGHfuwmK5RuEAEXbt8,4293
@@ -34,6 +35,7 @@ avrotize/dependency_resolver.py,sha256=LGOTutpobJ4kMjAwvs-l0Mt2tEoZFaXCazs-u38qn
 avrotize/dependency_version.py,sha256=tvbpO2VstTSTmNA5jbzQl48u6jnIM7BHyASQrrgsRYU,16844
 avrotize/jsonstoavro.py,sha256=ZzigsCjAxw_TflXCjTLKHTrPmkiZRZMpuaZICfT_r_I,120069
 avrotize/jsonstostructure.py,sha256=AXqrh3gJsQveWmC9Pfj1rTcUY_4KaDP7L9ObBSQehF4,147687
+avrotize/jsontoschema.py,sha256=bRLhBqN1tkKVFvmNWBtzMeWkNVj__dMspTxtzMwZoc4,4714
 avrotize/jstructtoavro.py,sha256=sOq7Ru1b8_ZLCEsnBqx3gsMWd7dPAaYxoraAD0bz6rk,33891
 avrotize/kstructtoavro.py,sha256=t97JY22n0uILK3WcvQu_Yp9ONvouJRLAC2bZ3rvZ1L0,2856
 avrotize/kustotoavro.py,sha256=1oEk9mbqmP3N5-V7mBHSXpbSlYFzjJ7ajIDNJZxA1r8,21756
@@ -42,6 +44,8 @@ avrotize/parquettoavro.py,sha256=iAPrSYNkiH3fBKNVDfIgeXkQbAiopa252ULJrGgmBDI,553
 avrotize/proto2parser.py,sha256=__9R3cqiUJXc_efPCZZcF7rt18kA7mfhmX0qm2v0eSw,19742
 avrotize/proto3parser.py,sha256=MfE84c-oAWWuzYmKlEZ5g5LUF7YzZaASFh2trX3UCaw,15604
 avrotize/prototoavro.py,sha256=hqXBGRxYojaEbEgoHZxXwMG4R1nWC7UMl_XNLWfqH38,17346
+avrotize/schema_inference.py,sha256=puhn81PxhZiWldD7rZ2IfUQY7-hCw5pcMkVcEsP1FGY,31413
+avrotize/sqltoavro.py,sha256=BpvsN8KJTp_0MLWl7JsbcQHvnA2hQgbwsJymtDKYXjo,48264
 avrotize/structuretocddl.py,sha256=RK_dTJf0oAo6BIBM48NHRcWC96OtUjlgUC6HzXs5Lkk,21234
 avrotize/structuretocpp.py,sha256=tBWOvyZPYQ1CHN6RgDnWlmzJ1giOyQ9SlHBHWvhPyiw,35898
 avrotize/structuretocsharp.py,sha256=NnHzeJcOWDbZ_LnGV6AW9hXgP7rQW6Lld9utzxO8l-g,128208
@@ -61,12 +65,14 @@ avrotize/structuretopython.py,sha256=d9EZVDHq7r-x0ZYZIRYfCP6kub7MkEROuvzjTJfNVv0
 avrotize/structuretorust.py,sha256=ChRmO7uzU-pMdDdS0Vtg-MVUaOaNhNUPwH-ZKKOHglU,35134
 avrotize/structuretots.py,sha256=zsN4ssX8rU4izOqXIiQcE0LQJ5wouydvCPoTWwSKXj4,35289
 avrotize/structuretoxsd.py,sha256=01VpasyWSMOx04sILHLP7H-WkhGdXAEGKohUUfgrNf0,32797
+avrotize/validate.py,sha256=isaDJ4E3O8SKehOROKCMnwE1-vPhkrVU5E-DDeThwlQ,7747
+avrotize/xmltoschema.py,sha256=I125hZtbzxzbE3BSYemYJBB8d-X9Zle0ooKVaiNu_bk,3726
 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=oAW_2X-b715kV7aajwuONZEMkyQUJGviG3GwnoUa7hU,387
-structurize-3.0.2.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
-structurize-3.0.2.dist-info/METADATA,sha256=3c5_rlTtVt9hq44svI_ve5VVxLzIMEZH98HwWIm8BWw,3669
-structurize-3.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-structurize-3.0.2.dist-info/entry_points.txt,sha256=biIH7jA5auhVqfbwHVk2gmD_gvrPYKgjpCAn0JWZ-Rs,55
-structurize-3.0.2.dist-info/top_level.txt,sha256=yn-yQ0Cm1O9fbF8KJgv4IIvX4YRGelKgPqZF1wS5P50,9
-structurize-3.0.2.dist-info/RECORD,,
+avrotize/dependencies/typescript/node22/package.json,sha256=XEiq9nTES4aSHdLMOTp3lt9urzg3pOtQHOZ6gTOCW9s,386
+structurize-3.1.0.dist-info/licenses/LICENSE,sha256=xGtQGygTETTtDQJafZCUbpsed3GxO6grmqig-jGEuSk,11348
+structurize-3.1.0.dist-info/METADATA,sha256=fbKqGwm-X-BiKIIF1eq4AFrd8AzYfy3Ova8s3r_N8Kc,3669
+structurize-3.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+structurize-3.1.0.dist-info/entry_points.txt,sha256=biIH7jA5auhVqfbwHVk2gmD_gvrPYKgjpCAn0JWZ-Rs,55
+structurize-3.1.0.dist-info/top_level.txt,sha256=yn-yQ0Cm1O9fbF8KJgv4IIvX4YRGelKgPqZF1wS5P50,9
+structurize-3.1.0.dist-info/RECORD,,

{structurize-3.0.2.dist-info → structurize-3.1.0.dist-info}/WHEEL

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