structurize 3.3.0__tar.gz → 3.3.1__tar.gz

{structurize-3.3.0/structurize.egg-info → structurize-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.3.0
+Version: 3.3.1
 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.3.0 → structurize-3.3.1}/avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '3.3.0'
-__version_tuple__ = version_tuple = (3, 3, 0)
+__version__ = version = '3.3.1'
+__version_tuple__ = version_tuple = (3, 3, 1)
 
-__commit_id__ = commit_id = 'g09d8d822a'
+__commit_id__ = commit_id = 'g670e64099'

{structurize-3.3.0 → structurize-3.3.1}/avrotize/choice_inference.py

@@ -214,6 +214,13 @@ def _detect_discriminators(
         if len(values) < 2:
             continue
         
+        # Skip boolean-like string values - these are flags, not discriminators
+        # A field with only "true"/"false" (or similar) values is not a type discriminator
+        normalized_values = {v.lower() if isinstance(v, str) else str(v).lower() for v in values}
+        boolean_values = {'true', 'false', 'yes', 'no', '0', '1'}
+        if normalized_values <= boolean_values:
+            continue
+        
         # Single cluster with multiple values - check if values create distinct groups
         if len(clusters) == 1:
             value_to_docs: Dict[str, List[DocumentInfo]] = defaultdict(list)

{structurize-3.3.0 → structurize-3.3.1}/avrotize/commands.json

@@ -764,7 +764,10 @@
         "avro_namespace": "args.namespace",
         "avro_schema_file": "output_file_path",
         "emit_cloudevents": "args.emit_cloudevents",
-        "emit_cloudevents_xregistry": "args.emit_xregistry"
+        "emit_cloudevents_xregistry": "args.emit_xregistry",
+        "sample_size": "args.sample_size",
+        "infer_choices": "args.infer_choices",
+        "choice_depth": "args.choice_depth"
       }
     },
     "extensions": [
@@ -819,6 +822,26 @@
         "type": "bool",
         "help": "Emit an xRegistry manifest with CloudEvents declarations for each table instead of a single Avrotize schema",
         "required": false
+      },
+      {
+        "name": "--sample-size",
+        "type": "int",
+        "help": "Maximum number of records to sample for dynamic field inference (0 = all)",
+        "default": 100,
+        "required": false
+      },
+      {
+        "name": "--infer-choices",
+        "type": "bool",
+        "help": "Detect discriminated unions in dynamic fields and emit as Avro unions with discriminator defaults",
+        "required": false
+      },
+      {
+        "name": "--choice-depth",
+        "type": "int",
+        "help": "Maximum nesting depth for recursive choice inference in dynamic fields (1 = root only)",
+        "default": 1,
+        "required": false
       }
     ],
     "suggested_output_file_path": "{kusto_database}.avsc",
@@ -846,6 +869,131 @@
     ],
     "skip_input_file_handling": true
   },
+  {
+    "command": "k2s",
+    "description": "Convert Kusto schema to JSON Structure schema",
+    "group": "1_Schemas",
+    "function": {
+      "name": "avrotize.kustotojstruct.convert_kusto_to_jstruct",
+      "args": {
+        "kusto_uri": "args.kusto_uri",
+        "kusto_database": "args.kusto_database",
+        "table_name": "args.table_name",
+        "base_id": "args.base_id",
+        "jstruct_schema_file": "output_file_path",
+        "emit_cloudevents": "args.emit_cloudevents",
+        "emit_cloudevents_xregistry": "args.emit_xregistry",
+        "sample_size": "args.sample_size",
+        "infer_choices": "args.infer_choices",
+        "choice_depth": "args.choice_depth",
+        "infer_enums": "args.infer_enums"
+      }
+    },
+    "extensions": [
+      ".kusto"
+    ],
+    "args": [
+      {
+        "name": "input",
+        "type": "str",
+        "nargs": "?",
+        "help": "Kusto file",
+        "required": false
+      },
+      {
+        "name": "--out",
+        "type": "str",
+        "help": "Path to the JSON Structure schema file",
+        "required": false
+      },
+      {
+        "name": "--kusto-uri",
+        "type": "str",
+        "help": "Kusto Cluster URI",
+        "required": false
+      },
+      {
+        "name": "--kusto-database",
+        "type": "str",
+        "help": "Kusto database",
+        "required": false
+      },
+      {
+        "name": "--table-name",
+        "type": "str",
+        "help": "Kusto table name",
+        "required": false
+      },
+      {
+        "name": "--base-id",
+        "type": "str",
+        "help": "Base URI for $id generation",
+        "required": false
+      },
+      {
+        "name": "--emit-cloudevents",
+        "type": "bool",
+        "help": "Emit CloudEvents declarations for each table",
+        "required": false
+      },
+      {
+        "name": "--emit-xregistry",
+        "type": "bool",
+        "help": "Emit an xRegistry manifest with CloudEvents declarations for each table instead of a single JSON Structure schema",
+        "required": false
+      },
+      {
+        "name": "--sample-size",
+        "type": "int",
+        "help": "Maximum number of records to sample for dynamic field inference (0 = all)",
+        "default": 100,
+        "required": false
+      },
+      {
+        "name": "--infer-choices",
+        "type": "bool",
+        "help": "Detect discriminated unions in dynamic fields and emit as choice types with discriminator defaults",
+        "required": false
+      },
+      {
+        "name": "--choice-depth",
+        "type": "int",
+        "help": "Maximum nesting depth for recursive choice inference in dynamic fields (1 = root only)",
+        "default": 1,
+        "required": false
+      },
+      {
+        "name": "--infer-enums",
+        "type": "bool",
+        "help": "Detect enum types from repeated string values with low cardinality in dynamic fields",
+        "required": false
+      }
+    ],
+    "suggested_output_file_path": "{kusto_database}.jstruct.json",
+    "prompts": [
+      {
+        "name": "--base-id",
+        "message": "Enter the base URI for $id generation",
+        "type": "str",
+        "required": false
+      },
+      {
+        "name": "--emit-cloudevents",
+        "message": "Emit CloudEvents declarations for each table?",
+        "type": "bool",
+        "default": false,
+        "required": false
+      },
+      {
+        "name": "--emit-xregistry",
+        "message": "Emit an xRegistry manifest with CloudEvents declarations?",
+        "type": "bool",
+        "default": false,
+        "required": false
+      }
+    ],
+    "skip_input_file_handling": true
+  },
   {
     "command": "a2sql",
     "description": "Convert Avrotize schema to SQL schema",
@@ -1167,7 +1315,11 @@
         "choice_depth": "args.choice_depth"
       }
     },
-    "extensions": [".json", ".jsonl", ".ndjson"],
+    "extensions": [
+      ".json",
+      ".jsonl",
+      ".ndjson"
+    ],
     "args": [
       {
         "name": "input",
@@ -1252,7 +1404,11 @@
         "infer_enums": "args.infer_enums"
       }
     },
-    "extensions": [".json", ".jsonl", ".ndjson"],
+    "extensions": [
+      ".json",
+      ".jsonl",
+      ".ndjson"
+    ],
     "args": [
       {
         "name": "input",
@@ -1343,7 +1499,9 @@
         "sample_size": "args.sample_size"
       }
     },
-    "extensions": [".xml"],
+    "extensions": [
+      ".xml"
+    ],
     "args": [
       {
         "name": "input",
@@ -1411,7 +1569,9 @@
         "sample_size": "args.sample_size"
       }
     },
-    "extensions": [".xml"],
+    "extensions": [
+      ".xml"
+    ],
     "args": [
       {
         "name": "input",
@@ -1480,7 +1640,10 @@
         "quiet": "args.quiet"
       }
     },
-    "extensions": [".json", ".jsonl"],
+    "extensions": [
+      ".json",
+      ".jsonl"
+    ],
     "args": [
       {
         "name": "input",
@@ -1667,7 +1830,10 @@
         "name": "--format",
         "type": "str",
         "help": "Output format: 'arrow' for binary Arrow IPC (default), 'schema' for JSON",
-        "choices": ["schema", "arrow"],
+        "choices": [
+          "schema",
+          "arrow"
+        ],
         "default": "arrow",
         "required": false
       }
@@ -1731,7 +1897,10 @@
         "name": "--format",
         "type": "str",
         "help": "Output format: 'arrow' for binary Arrow IPC (default), 'schema' for JSON",
-        "choices": ["schema", "arrow"],
+        "choices": [
+          "schema",
+          "arrow"
+        ],
         "default": "arrow",
         "required": false
       }
@@ -2700,7 +2869,10 @@
         "avro_annotation": "args.avro_annotation"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",

{structurize-3.3.0 → structurize-3.3.1}/avrotize/jsontoschema.py

@@ -110,7 +110,7 @@ def _load_json_values(input_files: List[str], sample_size: int) -> List[Any]:
     """Loads JSON values from files.
 
     Handles both single JSON documents and JSON Lines (JSONL) files.
-    Arrays at the root level are flattened into individual values.
+    Top-level arrays are treated as single array values, not flattened.
 
     Args:
         input_files: List of file paths
@@ -134,14 +134,8 @@ def _load_json_values(input_files: List[str], sample_size: int) -> List[Any]:
         # Try parsing as a single JSON document first
         try:
             data = json.loads(content)
-            if isinstance(data, list):
-                # Root-level array: each element is a separate value
-                for item in data:
-                    values.append(item)
-                    if sample_size > 0 and len(values) >= sample_size:
-                        break
-            else:
-                values.append(data)
+            # Treat any valid JSON (including arrays) as a single value
+            values.append(data)
             continue
         except json.JSONDecodeError:
             pass

{structurize-3.3.0 → structurize-3.3.1}/avrotize/kustotoavro.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, Tuple
 from azure.kusto.data import KustoClient, KustoConnectionStringBuilder
 from avrotize.common import get_tree_hash
 from avrotize.constants import AVRO_VERSION
+from avrotize.schema_inference import AvroSchemaInferrer
 
 JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | bool | int | None
 
@@ -14,7 +15,7 @@ JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | bool | int | None
 class KustoToAvro:
     """ Converts Kusto table schemas to Avro schema format."""
 
-    def __init__(self, kusto_uri, kusto_database, table_name: str | None, avro_namespace: str, avro_schema_path, emit_cloudevents: bool, emit_cloudevents_xregistry: bool, token_provider=None):
+    def __init__(self, kusto_uri, kusto_database, table_name: str | None, avro_namespace: str, avro_schema_path, emit_cloudevents: bool, emit_cloudevents_xregistry: bool, token_provider=None, sample_size: int = 100, infer_choices: bool = False, choice_depth: int = 1):
         """ Initializes the KustoToAvro class with the Kusto URI and database name. """
         kcsb = KustoConnectionStringBuilder.with_az_cli_authentication(kusto_uri) if not token_provider else KustoConnectionStringBuilder.with_token_provider(kusto_uri, token_provider)
         self.client = KustoClient(kcsb)
@@ -24,6 +25,9 @@ class KustoToAvro:
         self.avro_schema_path = avro_schema_path
         self.emit_xregistry = emit_cloudevents_xregistry
         self.emit_cloudevents = emit_cloudevents or emit_cloudevents_xregistry
+        self.sample_size = sample_size if sample_size > 0 else 100
+        self.infer_choices = infer_choices
+        self.choice_depth = choice_depth
         if self.emit_xregistry:
             if not self.avro_namespace:
                 raise ValueError(
@@ -172,20 +176,19 @@ class KustoToAvro:
             type_value: The value of the type column (if any)
         """
         type_column_name = type_column['Name'] if type_column else None
-        query = f"{table_name}"+(f' | where {type_column_name}=="{type_value}"' if type_column_name and type_value else '') + f" | project {column_name} | take 100"
+        query = f"{table_name}"+(f' | where {type_column_name}=="{type_value}"' if type_column_name and type_value else '') + f" | project {column_name} | take {self.sample_size}"
         rows = self.client.execute(self.kusto_database, query)
         values = [row[column_name] for row in rows.primary_results[0]]
         type_name = type_value if type_value else f"{table_name}.{column_name}"
-        unique_types = self.consolidated_type_list(type_name, values)
-        if len(unique_types) > 1:
-            # Using a union of inferred types
-            return unique_types
-        elif len(unique_types) == 1:
-            # Single type, no need for union
-            return unique_types[0]
-        else:
-            # No values, default to string
-            return "string"
+        
+        # Use the new AvroSchemaInferrer for consistent inference
+        inferrer = AvroSchemaInferrer(
+            namespace=self.avro_namespace, 
+            altnames_key='kql',
+            infer_choices=self.infer_choices,
+            choice_depth=self.choice_depth
+        )
+        return inferrer.infer_from_json_values(type_name, values)
 
     type_map : Dict[str, JsonNode] = {
             "int": "int", 
@@ -440,7 +443,7 @@ class KustoToAvro:
             json.dump(output, avro_file, indent=4)
 
 
-def convert_kusto_to_avro(kusto_uri: str, kusto_database: str, table_name: str | None, avro_namespace: str, avro_schema_file: str, emit_cloudevents:bool, emit_cloudevents_xregistry: bool, token_provider=None):
+def convert_kusto_to_avro(kusto_uri: str, kusto_database: str, table_name: str | None, avro_namespace: str, avro_schema_file: str, emit_cloudevents:bool, emit_cloudevents_xregistry: bool, token_provider=None, sample_size: int = 100, infer_choices: bool = False, choice_depth: int = 1):
     """ Converts Kusto table schemas to Avro schema format."""
     
     if not kusto_uri:
@@ -451,5 +454,5 @@ def convert_kusto_to_avro(kusto_uri: str, kusto_database: str, table_name: str |
         avro_namespace = kusto_database
     
     kusto_to_avro = KustoToAvro(
-        kusto_uri, kusto_database, table_name, avro_namespace, avro_schema_file,emit_cloudevents, emit_cloudevents_xregistry, token_provider=token_provider)
+        kusto_uri, kusto_database, table_name, avro_namespace, avro_schema_file, emit_cloudevents, emit_cloudevents_xregistry, token_provider=token_provider, sample_size=sample_size, infer_choices=infer_choices, choice_depth=choice_depth)
     return kusto_to_avro.process_all_tables()

structurize-3.3.1/avrotize/kustotojstruct.py

@@ -0,0 +1,247 @@
+""" Converts Kusto table schemas to JSON Structure schema format. """
+
+import os
+import json
+from typing import Dict, List
+from azure.kusto.data import KustoClient, KustoConnectionStringBuilder
+from avrotize.schema_inference import JsonStructureSchemaInferrer
+
+JsonNode = Dict[str, 'JsonNode'] | List['JsonNode'] | str | bool | int | None
+
+
+class KustoToJsonStructure:
+    """ Converts Kusto table schemas to JSON Structure schema format."""
+
+    def __init__(self, kusto_uri, kusto_database, table_name: str | None, base_id: str, jstruct_schema_path, emit_cloudevents: bool, emit_cloudevents_xregistry: bool, token_provider=None, sample_size: int = 100, infer_choices: bool = False, choice_depth: int = 1, infer_enums: bool = False):
+        """ Initializes the KustoToJsonStructure class with the Kusto URI and database name. """
+        kcsb = KustoConnectionStringBuilder.with_az_cli_authentication(kusto_uri) if not token_provider else KustoConnectionStringBuilder.with_token_provider(kusto_uri, token_provider)
+        self.client = KustoClient(kcsb)
+        self.kusto_database = kusto_database
+        self.single_table_name = table_name
+        self.base_id = base_id if base_id else f"https://{kusto_database}.example.com/"
+        self.jstruct_schema_path = jstruct_schema_path
+        self.emit_xregistry = emit_cloudevents_xregistry
+        self.emit_cloudevents = emit_cloudevents or emit_cloudevents_xregistry
+        self.sample_size = sample_size if sample_size > 0 else 100
+        self.infer_choices = infer_choices
+        self.choice_depth = choice_depth
+        self.infer_enums = infer_enums
+        if self.emit_xregistry:
+            if not self.base_id:
+                raise ValueError(
+                    "The base_id must be specified when emit_cloudevents_xregistry is True")
+        self.generated_types: List[str] = []
+
+    def fetch_table_schema_and_docs(self, table_name: str):
+        """ Fetches the schema and docstrings for a given table."""
+        query = f".show table {table_name} schema as json"
+        response = self.client.execute(self.kusto_database, query)
+        schema_json = response.primary_results[0][0]['Schema']
+        schema = json.loads(schema_json)
+        return schema
+
+    def infer_dynamic_schema(self, table_name: str, column_name: str, type_column: dict | None, type_value: str | None) -> JsonNode:
+        """ 
+        Infers the schema for a dynamic column. If a type column is provided, it will infer the schema based 
+        on constraining the result set by the type column.
+
+        Args:
+            table_name: The name of the table.
+            column_name: The name of the column.
+            type_column: The type column (if any)
+            type_value: The value of the type column (if any)
+        """
+        type_column_name = type_column['Name'] if type_column else None
+        query = f"{table_name}"+(f' | where {type_column_name}=="{type_value}"' if type_column_name and type_value else '') + f" | project {column_name} | take {self.sample_size}"
+        rows = self.client.execute(self.kusto_database, query)
+        values = [row[column_name] for row in rows.primary_results[0]]
+        type_name = type_value if type_value else f"{table_name}.{column_name}"
+        
+        # Use the JsonStructureSchemaInferrer for consistent inference
+        inferrer = JsonStructureSchemaInferrer(
+            base_id=self.base_id, 
+            infer_choices=self.infer_choices,
+            choice_depth=self.choice_depth,
+            infer_enums=self.infer_enums
+        )
+        return inferrer.infer_from_json_values(type_name, values)
+
+    type_map : Dict[str, JsonNode] = {
+            "int": "int32", 
+            "long": "int64", 
+            "string": "string",
+            "real": "double", 
+            "bool": "boolean",
+            "datetime": "datetime",
+            "timespan": "duration",
+            "decimal": "decimal",
+            "dynamic": "object"
+        }
+    
+    def map_kusto_type_to_jstruct_type(self, kusto_type, table_name, column_name, type_column: dict | None, type_value: str | None) -> JsonNode:
+        """ Maps Kusto types to JSON Structure types."""
+        if kusto_type == "dynamic":
+            return self.infer_dynamic_schema(table_name, column_name, type_column, type_value)
+        return self.type_map.get(kusto_type, "string")
+
+    def kusto_to_jstruct_schema(self, kusto_schema: dict, table_name: str) -> JsonNode:
+        """ Converts a Kusto schema to JSON Structure schema."""
+        column_names = set([column['Name'].lstrip('_')
+                           for column in kusto_schema['OrderedColumns']])
+        type_values: List[str|None] = []
+        type_column: Dict[str, JsonNode] = {}
+        is_cloudevent = False
+        if self.emit_cloudevents:
+            is_cloudevent = 'type' in column_names and 'source' in column_names and 'data' in column_names and 'id' in column_names
+            if is_cloudevent:
+                type_column = next(
+                    (column for column in kusto_schema['OrderedColumns'] if column['Name'].lstrip('_') == 'type'), {})
+                type_sampling_query = f"{table_name} | distinct {type_column['Name']}"
+                type_sampling_rows = self.client.execute(
+                    self.kusto_database, type_sampling_query)
+                type_values.extend([row[type_column['Name']]
+                                   for row in type_sampling_rows.primary_results[0]])
+
+        if len(type_values) == 0:
+            type_values.append(None)
+
+        schemas: List[JsonNode] = []
+        for type_value in type_values:
+            schema: JsonNode = {}
+            properties: Dict[str, JsonNode] = {}
+            type_name = type_value if type_value and isinstance(type_value, str) else table_name
+                
+            if is_cloudevent:
+                # get just the 'data' column and infer the schema
+                column = next(col for col in kusto_schema['OrderedColumns'] if col['Name'].lstrip('_') == 'data')
+                data_schemas: JsonNode = self.map_kusto_type_to_jstruct_type(
+                        column['CslType'], table_name, column['Name'], type_column, type_value)           
+                if isinstance(data_schemas, dict):
+                    data_schemas = [data_schemas]
+                if isinstance(data_schemas, list):
+                    for schema in data_schemas:
+                        if not isinstance(schema, dict) or "type" not in schema or schema["type"] != "object":
+                            schema = self.wrap_schema_in_root_record(schema, type_name)
+                        self.apply_schema_attributes(schema, kusto_schema, table_name, type_value)
+                        schemas.append(schema)
+            else:
+                for column in kusto_schema['OrderedColumns']:
+                    jstruct_type = self.map_kusto_type_to_jstruct_type(
+                        column['CslType'], table_name, column['Name'], type_column, type_value)
+                    
+                    # For dynamic columns, jstruct_type is a full schema object
+                    # For static columns, it's a type string
+                    if isinstance(jstruct_type, dict):
+                        # Full schema object from inference - use directly as property schema
+                        prop = jstruct_type
+                    else:
+                        prop = {"type": jstruct_type}
+                    
+                    doc: JsonNode = column.get('DocString', '')
+                    if doc:
+                        prop["description"] = doc
+                    properties[column['Name']] = prop
+                    
+                schema = {
+                    "type": "object",
+                    "properties": properties
+                }
+                self.apply_schema_attributes(schema, kusto_schema, table_name, type_value)
+                schemas.append(schema)
+
+        return schemas if len(schemas) > 1 else schemas[0]
+
+
+    def wrap_schema_in_root_record(self, schema: JsonNode, type_name: str):
+        """ Wraps a schema in a root object."""
+        # If schema is already a complete type object, use it directly in properties
+        # Otherwise treat it as a type string
+        if isinstance(schema, dict) and "type" in schema:
+            data_prop = schema
+        else:
+            data_prop = {"type": schema}
+        
+        data_prop["root"] = True
+        
+        record: Dict[str, JsonNode] = {
+            "type": "object",
+            "properties": {
+                "data": data_prop
+            }
+        }
+        return record
+    
+    def apply_schema_attributes(self, schema, kusto_schema, table_name, type_value):
+        """ Applies schema attributes to the schema."""
+        if isinstance(schema, dict):
+            type_name = type_value if type_value and isinstance(type_value, str) else table_name
+            schema["$id"] = f"{self.base_id}{type_name}"
+            
+            # Add description from table doc string if available
+            if 'DocString' in kusto_schema:
+                schema["description"] = kusto_schema['DocString']
+
+    def fetch_all_table_names(self) -> List[str]:
+        """ Fetches all table names from the Kusto database."""
+        query = ".show tables"
+        rows = self.client.execute(self.kusto_database, query)
+        table_names = [row['TableName'] for row in rows.primary_results[0]]
+        return table_names
+
+    def process_all_tables(self):
+        """ Processes all tables in the Kusto database."""
+        if self.single_table_name:
+            table_names = [self.single_table_name]
+        else:
+            table_names = self.fetch_all_table_names()
+        
+        all_schemas = []
+        for table_name in table_names:
+            kusto_schema = self.fetch_table_schema_and_docs(table_name)
+            jstruct_schema = self.kusto_to_jstruct_schema(kusto_schema, table_name)
+            
+            if isinstance(jstruct_schema, list):
+                all_schemas.extend(jstruct_schema)
+            else:
+                all_schemas.append(jstruct_schema)
+        
+        # Write output
+        output_dir = os.path.dirname(self.jstruct_schema_path)
+        if output_dir and not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+            
+        if self.emit_xregistry:
+            # Create xRegistry manifest
+            output = {
+                "$schema": "https://cloudevents.io/schemas/registry",
+                "specversion": "0.5-wip",
+                "endpoints": {},
+                "messagegroups": {},
+                "schemagroups": {
+                    f"{self.kusto_database}": {
+                        "schemas": {schema.get("$id", f"schema_{i}"): {"format": "JSONStructure/1.0", "schema": schema} 
+                                   for i, schema in enumerate(all_schemas)}
+                    }
+                }
+            }
+        else:
+            # Single schema or array of schemas
+            output = all_schemas if len(all_schemas) > 1 else all_schemas[0] if all_schemas else {}
+        
+        with open(self.jstruct_schema_path, 'w', encoding='utf-8') as jstruct_file:
+            json.dump(output, jstruct_file, indent=4)
+
+
+def convert_kusto_to_jstruct(kusto_uri: str, kusto_database: str, table_name: str | None, base_id: str, jstruct_schema_file: str, emit_cloudevents: bool, emit_cloudevents_xregistry: bool, token_provider=None, sample_size: int = 100, infer_choices: bool = False, choice_depth: int = 1, infer_enums: bool = False):
+    """ Converts Kusto table schemas to JSON Structure schema format."""
+    
+    if not kusto_uri:
+        raise ValueError("kusto_uri is required")
+    if not kusto_database:
+        raise ValueError("kusto_database is required")
+    if not base_id:
+        base_id = f"https://{kusto_database}.example.com/"
+    
+    kusto_to_jstruct = KustoToJsonStructure(
+        kusto_uri, kusto_database, table_name, base_id, jstruct_schema_file, emit_cloudevents, emit_cloudevents_xregistry, token_provider=token_provider, sample_size=sample_size, infer_choices=infer_choices, choice_depth=choice_depth, infer_enums=infer_enums)
+    return kusto_to_jstruct.process_all_tables()