structurize 3.3.1__tar.gz → 3.4.0__tar.gz

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

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

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

{structurize-3.3.1 → structurize-3.4.0}/avrotize/avrotize.py

@@ -92,7 +92,7 @@ def main():
             print(f"Error: Command {args.command} not found.")
             exit(1)
         
-        input_file_path = args.input or getattr(args, 'avsc', None) or getattr(args, 'proto', None) or getattr(args, 'jsons', None) or getattr(args, 'xsd', None) or getattr(args, 'kusto_uri', None) or getattr(args, 'parquet', None) or getattr(args, 'asn', None) or getattr(args, 'kstruct', None)
+        input_file_path = getattr(args, 'input', None) or getattr(args, 'avsc', None) or getattr(args, 'proto', None) or getattr(args, 'jsons', None) or getattr(args, 'xsd', None) or getattr(args, 'kusto_uri', None) or getattr(args, 'parquet', None) or getattr(args, 'asn', None) or getattr(args, 'kstruct', None)
         temp_input = None
         skip_input_file_handling = command.get('skip_input_file_handling', False)
         if not skip_input_file_handling:

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

@@ -214,11 +214,19 @@ 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:
+        # Discriminators must be identifier-like strings (type names, enum values)
+        # Valid: "PlayerTracking", "ball_data", "goal-event", "Event.Type"
+        # Invalid: "1", "2024/2025", "true", "2024-01-15T10:30:00Z", UUIDs
+        import re
+        def is_valid_discriminator(s: str) -> bool:
+            """Check if a string looks like a type name or identifier."""
+            if not s or not isinstance(s, str):
+                return False
+            # Must start with a letter, contain only alphanumeric, underscore, hyphen, dot
+            # This matches typical identifiers: PascalCase, camelCase, snake_case, kebab-case
+            return bool(re.match(r'^[A-Za-z][A-Za-z0-9_\-\.]*$', s))
+        
+        if not all(is_valid_discriminator(v) for v in values):
             continue
         
         # Single cluster with multiple values - check if values create distinct groups

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

@@ -4405,5 +4405,31 @@
         "required": false
       }
     ]
+  },
+  {
+    "command": "mcp",
+    "description": "Run Avrotize as a local MCP server exposing conversion tools",
+    "group": "7_Utility",
+    "function": {
+      "name": "avrotize.mcp_server.run_mcp_server",
+      "args": {
+        "transport": "args.transport"
+      }
+    },
+    "extensions": [],
+    "args": [
+      {
+        "name": "--transport",
+        "type": "str",
+        "help": "MCP transport type",
+        "choices": [
+          "stdio"
+        ],
+        "default": "stdio",
+        "required": false
+      }
+    ],
+    "prompts": [],
+    "skip_input_file_handling": true
   }
 ]

structurize-3.4.0/avrotize/mcp_server.py

@@ -0,0 +1,253 @@
+"""MCP server integration for Avrotize conversions."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import tempfile
+from typing import Any, Dict, List
+
+from avrotize.avrotize import dynamic_import, load_commands
+
+
+def _command_dest(arg: Dict[str, Any]) -> str:
+    name = arg["name"]
+    if name.startswith("-"):
+        return arg.get("dest", name.lstrip("-").replace("-", "_").replace(".", "_"))
+    return name
+
+
+def _coerce_value(value: Any, arg_type: str) -> Any:
+    if value is None:
+        return None
+    if arg_type == "bool":
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, (int, float)):
+            return bool(value)
+        sval = str(value).strip().lower()
+        return sval in {"1", "true", "yes", "y", "on"}
+    if arg_type == "int":
+        return int(value)
+    if arg_type == "float":
+        return float(value)
+    return str(value) if arg_type == "str" else value
+
+
+def _build_namespace(command: Dict[str, Any], options: Dict[str, Any]) -> argparse.Namespace:
+    namespace = argparse.Namespace()
+    normalized_options = {
+        key.lstrip("-").replace("-", "_"): value
+        for key, value in (options or {}).items()
+    }
+
+    for arg in command.get("args", []):
+        dest = _command_dest(arg)
+        default_value = arg.get("default", False if arg.get("type") == "bool" else None)
+        setattr(namespace, dest, default_value)
+        if dest in normalized_options:
+            setattr(namespace, dest, _coerce_value(normalized_options[dest], arg["type"]))
+
+    return namespace
+
+
+def _resolve_input_path(command_args: argparse.Namespace, explicit_input_path: str | None) -> str | None:
+    if explicit_input_path:
+        return explicit_input_path
+    return (
+        getattr(command_args, "input", None)
+        or getattr(command_args, "avsc", None)
+        or getattr(command_args, "proto", None)
+        or getattr(command_args, "jsons", None)
+        or getattr(command_args, "xsd", None)
+        or getattr(command_args, "kusto_uri", None)
+        or getattr(command_args, "parquet", None)
+        or getattr(command_args, "asn", None)
+        or getattr(command_args, "kstruct", None)
+    )
+
+
+def _find_command(command_name: str) -> Dict[str, Any] | None:
+    return next((cmd for cmd in load_commands() if cmd.get("command") == command_name), None)
+
+
+def _list_commands() -> List[Dict[str, Any]]:
+    commands = load_commands()
+    result: List[Dict[str, Any]] = []
+    for command in commands:
+        if command.get("command") == "mcp":
+            continue
+        result.append(
+            {
+                "command": command.get("command"),
+                "description": command.get("description"),
+                "group": command.get("group"),
+                "args": [arg.get("name") for arg in command.get("args", [])],
+            }
+        )
+    return result
+
+
+def _describe_capabilities() -> Dict[str, Any]:
+    commands = load_commands()
+    command_names = [cmd.get("command") for cmd in commands if cmd.get("command") != "mcp"]
+    return {
+        "server": "avrotize",
+        "purpose": "Schema conversion and schema-driven code generation",
+        "use_when": [
+            "Converting between schema formats (Avro, JSON Schema, Proto, XSD, Parquet, etc.)",
+            "Generating code from Avro/JSON Structure schemas (C#, Java, Python, TypeScript, JavaScript, Rust, Go, C++)",
+            "Inferring schemas from sample JSON/XML/CSV/parquet inputs",
+        ],
+        "do_not_use_when": [
+            "Task is unrelated to schema conversion or code generation",
+            "Task requires arbitrary code execution outside avrotize command set",
+        ],
+        "recommended_flow": [
+            "Call describe_capabilities for high-level routing",
+            "Call list_conversions to discover available commands",
+            "Call get_conversion(command) to inspect required args/options",
+            "Call run_conversion(...) to execute",
+        ],
+        "tools": {
+            "describe_capabilities": "High-level guidance for when and how to use this server",
+            "list_conversions": "List available conversion/code generation commands",
+            "get_conversion": "Inspect metadata and args for a specific command",
+            "run_conversion": "Execute a specific conversion command",
+        },
+        "command_count": len(command_names),
+        "commands": command_names,
+    }
+
+
+def _execute_conversion(
+    command_name: str,
+    input_path: str | None = None,
+    input_content: str | None = None,
+    output_path: str | None = None,
+    options: Dict[str, Any] | None = None,
+) -> Dict[str, Any]:
+    command = _find_command(command_name)
+    if not command:
+        raise ValueError(f"Unknown command '{command_name}'.")
+
+    command_args = _build_namespace(command, options or {})
+    temp_input_path = None
+    temp_output_path = None
+
+    try:
+        resolved_input = _resolve_input_path(command_args, input_path)
+        skip_input_file_handling = command.get("skip_input_file_handling", False)
+        if not skip_input_file_handling and not resolved_input:
+            if input_content is None:
+                raise ValueError("This command requires input_path or input_content.")
+            temp_input = tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-8")
+            temp_input.write(input_content)
+            temp_input.flush()
+            temp_input.close()
+            temp_input_path = temp_input.name
+            resolved_input = temp_input_path
+
+        if not output_path and any(v == "output_file_path" for v in command.get("function", {}).get("args", {}).values()):
+            temp_output = tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-8")
+            temp_output_path = temp_output.name
+            temp_output.close()
+            output_path = temp_output_path
+
+        module_name, func_name = command["function"]["name"].rsplit(".", 1)
+        func = dynamic_import(module_name, func_name)
+
+        func_args: Dict[str, Any] = {}
+        for arg_name, arg_value in command["function"]["args"].items():
+            if arg_value == "input_file_path":
+                func_args[arg_name] = resolved_input
+            elif arg_value == "output_file_path":
+                func_args[arg_name] = output_path
+            elif isinstance(arg_value, str) and arg_value.startswith("args."):
+                attr_name = arg_value[5:]
+                if hasattr(command_args, attr_name):
+                    func_args[arg_name] = getattr(command_args, attr_name)
+            else:
+                func_args[arg_name] = arg_value
+
+        func(**func_args)
+
+        output_content = None
+        if temp_output_path and os.path.exists(temp_output_path):
+            with open(temp_output_path, "r", encoding="utf-8") as out_file:
+                output_content = out_file.read()
+
+        return {
+            "success": True,
+            "command": command_name,
+            "output_path": output_path,
+            "output_content": output_content,
+        }
+    finally:
+        if temp_input_path and os.path.exists(temp_input_path):
+            os.remove(temp_input_path)
+        if temp_output_path and os.path.exists(temp_output_path):
+            os.remove(temp_output_path)
+
+
+def run_mcp_server(transport: str = "stdio"):
+    """Run avrotize as a local MCP server.
+
+    Exposes conversion tools to MCP clients.
+    """
+    try:
+        from mcp.server.fastmcp import FastMCP
+    except ImportError as exc:
+        raise RuntimeError(
+            "MCP support is not installed. Install with: pip install mcp"
+        ) from exc
+
+    if transport != "stdio":
+        raise ValueError("Only 'stdio' transport is currently supported.")
+
+    mcp = FastMCP("avrotize")
+
+    @mcp.tool()
+    def describe_capabilities() -> Dict[str, Any]:
+        """Describe when this server should be used and how to invoke it."""
+        return _describe_capabilities()
+
+    @mcp.tool()
+    def list_conversions() -> List[Dict[str, Any]]:
+        """List available Avrotize conversion commands."""
+        return _list_commands()
+
+    @mcp.tool()
+    def get_conversion(command: str) -> Dict[str, Any]:
+        """Get metadata for a specific conversion command."""
+        cmd = _find_command(command)
+        if not cmd:
+            raise ValueError(f"Unknown command '{command}'.")
+        return {
+            "command": cmd.get("command"),
+            "description": cmd.get("description"),
+            "group": cmd.get("group"),
+            "args": cmd.get("args", []),
+        }
+
+    @mcp.tool()
+    def run_conversion(
+        command: str,
+        input_path: str = "",
+        input_content: str = "",
+        output_path: str = "",
+        options: Dict[str, Any] | None = None,
+    ) -> Dict[str, Any]:
+        """Run a conversion command and return conversion output information."""
+        return _execute_conversion(
+            command_name=command,
+            input_path=input_path or None,
+            input_content=input_content or None,
+            output_path=output_path or None,
+            options=options or {},
+        )
+
+    try:
+        mcp.run(transport="stdio")
+    except TypeError:
+        mcp.run()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.3.1
+Version: 3.4.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.3.1 → structurize-3.4.0}/structurize.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ pyproject.toml
 ../avrotize/kstructtoavro.py
 ../avrotize/kustotoavro.py
 ../avrotize/kustotojstruct.py
+../avrotize/mcp_server.py
 ../avrotize/openapitostructure.py
 ../avrotize/parquettoavro.py
 ../avrotize/proto2parser.py
@@ -225,6 +226,7 @@ avrotize/jstructtoavro.py
 avrotize/kstructtoavro.py
 avrotize/kustotoavro.py
 avrotize/kustotojstruct.py
+avrotize/mcp_server.py
 avrotize/openapitostructure.py
 avrotize/parquettoavro.py
 avrotize/proto2parser.py