structurize 3.4.3__tar.gz → 3.5.0__tar.gz

{structurize-3.4.3/structurize.egg-info → structurize-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.4.3
+Version: 3.5.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.4.3 → structurize-3.5.0}/avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '3.4.3'
-__version_tuple__ = version_tuple = (3, 4, 3)
+__version__ = version = '3.5.0'
+__version_tuple__ = version_tuple = (3, 5, 0)
 
-__commit_id__ = commit_id = 'g1ee27c8b4'
+__commit_id__ = commit_id = 'g95f637e11'

{structurize-3.4.3 → structurize-3.5.0}/avrotize/avrotojava.py

@@ -4,8 +4,8 @@
 import json
 import os
 from typing import Dict, List, Tuple, Union
-from avrotize.constants import (AVRO_VERSION, JACKSON_VERSION, JDK_VERSION, 
-                                  JUNIT_VERSION, MAVEN_COMPILER_VERSION, MAVEN_SUREFIRE_VERSION)
+from avrotize.constants import (AVRO_VERSION, JACKSON_ANNOTATIONS_VERSION, JACKSON_VERSION,
+                                JDK_VERSION, JUNIT_VERSION, MAVEN_COMPILER_VERSION, MAVEN_SUREFIRE_VERSION)
 
 from avrotize.common import pascal, camel, is_generic_avro_type, inline_avro_references, build_flat_type_dict
 
@@ -42,7 +42,7 @@ POM_CONTENT = """<?xml version="1.0" encoding="UTF-8"?>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>{JACKSON_VERSION}</version>
+            <version>{JACKSON_ANNOTATIONS_VERSION}</version>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -2160,6 +2160,7 @@ class AvroToJava:
                     artifactid=artifactid, 
                     AVRO_VERSION=AVRO_VERSION, 
                     JACKSON_VERSION=JACKSON_VERSION, 
+                    JACKSON_ANNOTATIONS_VERSION=JACKSON_ANNOTATIONS_VERSION,
                     JDK_VERSION=JDK_VERSION, 
                     JUNIT_VERSION=JUNIT_VERSION,
                     MAVEN_COMPILER_VERSION=MAVEN_COMPILER_VERSION,

{structurize-3.4.3 → structurize-3.5.0}/avrotize/constants.py

@@ -17,61 +17,66 @@ try:
 except ValueError:
     JACKSON_VERSION = '2.18.2'  # Fallback
 
+try:
+    JACKSON_ANNOTATIONS_VERSION = get_dependency_version('java', 'jdk21', 'com.fasterxml.jackson.core:jackson-annotations')
+except ValueError:
+    JACKSON_ANNOTATIONS_VERSION = '2.18.2'  # Fallback
+
 JDK_VERSION = '21'
 
 # C# dependencies  
 try:
-    CSHARP_AVRO_VERSION = get_dependency_version('cs', 'net90', 'Apache.Avro')
+    CSHARP_AVRO_VERSION = get_dependency_version('cs', 'net100', 'Apache.Avro')
 except ValueError:
     CSHARP_AVRO_VERSION = '1.12.0'
 
 try:
-    NEWTONSOFT_JSON_VERSION = get_dependency_version('cs', 'net90', 'Newtonsoft.Json')
+    NEWTONSOFT_JSON_VERSION = get_dependency_version('cs', 'net100', 'Newtonsoft.Json')
 except ValueError:
     NEWTONSOFT_JSON_VERSION = '13.0.3'
 
 try:
-    SYSTEM_TEXT_JSON_VERSION = get_dependency_version('cs', 'net90', 'System.Text.Json')
+    SYSTEM_TEXT_JSON_VERSION = get_dependency_version('cs', 'net100', 'System.Text.Json')
 except ValueError:
     SYSTEM_TEXT_JSON_VERSION = '9.0.3'
 
 try:
-    SYSTEM_MEMORY_DATA_VERSION = get_dependency_version('cs', 'net90', 'System.Memory.Data')
+    SYSTEM_MEMORY_DATA_VERSION = get_dependency_version('cs', 'net100', 'System.Memory.Data')
 except ValueError:
     SYSTEM_MEMORY_DATA_VERSION = '9.0.3'
 
 try:
-    PROTOBUF_NET_VERSION = get_dependency_version('cs', 'net90', 'protobuf-net')
+    PROTOBUF_NET_VERSION = get_dependency_version('cs', 'net100', 'protobuf-net')
 except ValueError:
     PROTOBUF_NET_VERSION = '3.2.30'
 
 try:
-    NUNIT_VERSION = get_dependency_version('cs', 'net90', 'NUnit')
+    NUNIT_VERSION = get_dependency_version('cs', 'net100', 'NUnit')
 except ValueError:
     NUNIT_VERSION = '4.3.2'
 
 try:
-    NUNIT_ADAPTER_VERSION = get_dependency_version('cs', 'net90', 'NUnit3TestAdapter')
+    NUNIT_ADAPTER_VERSION = get_dependency_version('cs', 'net100', 'NUnit3TestAdapter')
 except ValueError:
     NUNIT_ADAPTER_VERSION = '5.0.0'
 
 try:
-    MSTEST_SDK_VERSION = get_dependency_version('cs', 'net90', 'Microsoft.NET.Test.Sdk')
+    MSTEST_SDK_VERSION = get_dependency_version('cs', 'net100', 'Microsoft.NET.Test.Sdk')
 except ValueError:
     MSTEST_SDK_VERSION = '17.13.0'
 
 try:
-    COVERLET_VERSION = get_dependency_version('cs', 'net90', 'coverlet.collector')
+    COVERLET_VERSION = get_dependency_version('cs', 'net100', 'coverlet.collector')
 except ValueError:
     COVERLET_VERSION = '6.0.4'
 
 try:
-    MSGPACK_VERSION = get_dependency_version('cs', 'net90', 'MessagePack')
+    MSGPACK_VERSION = get_dependency_version('cs', 'net100', 'MessagePack')
 except ValueError:
     MSGPACK_VERSION = '2.5.187'
 
 try:
-    CBOR_VERSION = get_dependency_version('cs', 'net90', 'Dahomey.Cbor')
+    CBOR_VERSION = get_dependency_version('cs', 'net100', 'Dahomey.Cbor')
 except ValueError:
     CBOR_VERSION = '1.25.1'
 
@@ -89,4 +94,4 @@ except ValueError:
 try:
     MAVEN_COMPILER_VERSION = get_dependency_version('java', 'jdk21', 'org.apache.maven.plugins:maven-compiler-plugin')
 except ValueError:
-    MAVEN_COMPILER_VERSION = '3.13.0'
+    MAVEN_COMPILER_VERSION = '3.13.0'

{structurize-3.4.3 → structurize-3.5.0}/avrotize/dependencies/typescript/node22/package.json

@@ -9,7 +9,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.0.3",
-    "typescript": "^5.7.2",
+    "typescript": "^6.0.2",
     "jest": "^30.2.0",
     "@types/jest": "^30.0.0"
   }

{structurize-3.4.3 → structurize-3.5.0}/avrotize/mcp_server.py

@@ -1,14 +1,27 @@
-"""MCP server integration for Avrotize conversions."""
+"""MCP server integration for Avrotize conversions.
+
+Implements the MCP (Model Context Protocol) stdio transport directly via
+JSON-RPC 2.0 over stdin/stdout to avoid the heavy ``mcp`` library import
+(~2-3 s for uvicorn, starlette, httpx, pydantic).  The ``mcp`` library
+is used only as a fallback when *explicitly* requested.
+"""
 
 from __future__ import annotations
 
 import argparse
+import json as _json
 import os
+import sys
 import tempfile
 from typing import Any, Dict, List
 
 from avrotize.avrotize import dynamic_import, load_commands
 
+# ---------------------------------------------------------------------------
+# MCP protocol version supported by this server
+# ---------------------------------------------------------------------------
+_MCP_PROTOCOL_VERSION = "2025-03-26"
+
 
 def _command_dest(arg: Dict[str, Any]) -> str:
     name = arg["name"]
@@ -227,10 +240,192 @@ def _execute_conversion(
             os.remove(temp_output_path)
 
 
+def _tool_schemas() -> List[Dict[str, Any]]:
+    """Return MCP tool definitions for the four exposed tools."""
+    return [
+        {
+            "name": "describe_capabilities",
+            "description": "Describe when this server should be used and how to invoke it.",
+            "inputSchema": {"type": "object", "properties": {}},
+        },
+        {
+            "name": "list_conversions",
+            "description": "List available Avrotize conversion commands.",
+            "inputSchema": {"type": "object", "properties": {}},
+        },
+        {
+            "name": "get_conversion",
+            "description": "Get metadata for a specific conversion command.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "The conversion command name."},
+                },
+                "required": ["command"],
+            },
+        },
+        {
+            "name": "run_conversion",
+            "description": "Run a conversion command and return conversion output information.",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "The conversion command name."},
+                    "input_path": {"type": "string", "description": "Path to the input file.", "default": ""},
+                    "input_content": {"type": "string", "description": "Inline input content.", "default": ""},
+                    "output_path": {"type": "string", "description": "Path for the output file.", "default": ""},
+                    "options": {
+                        "type": "object",
+                        "description": "Additional command options.",
+                        "additionalProperties": True,
+                    },
+                },
+                "required": ["command"],
+            },
+        },
+    ]
+
+
+def _dispatch_tool(name: str, arguments: Dict[str, Any]) -> Any:
+    """Dispatch a tool call by *name* and return a Python object."""
+    if name == "describe_capabilities":
+        return _describe_capabilities()
+    if name == "list_conversions":
+        return _list_commands()
+    if name == "get_conversion":
+        return _get_conversion_handler(arguments)
+    if name == "run_conversion":
+        return _run_conversion_handler(arguments)
+    raise ValueError(f"Unknown tool '{name}'.")
+
+
+def _get_conversion_handler(args: Dict[str, Any]) -> Dict[str, Any]:
+    command_name = args.get("command", "")
+    cmd = _find_command(command_name)
+    if not cmd:
+        raise ValueError(f"Unknown command '{command_name}'.")
+    return {
+        "command": cmd.get("command"),
+        "description": cmd.get("description"),
+        "group": cmd.get("group"),
+        "args": cmd.get("args", []),
+    }
+
+
+def _run_conversion_handler(args: Dict[str, Any]) -> Dict[str, Any]:
+    return _execute_conversion(
+        command_name=args.get("command", ""),
+        input_path=args.get("input_path") or None,
+        input_content=args.get("input_content") or None,
+        output_path=args.get("output_path") or None,
+        options=args.get("options") or {},
+    )
+
+
+# ---------------------------------------------------------------------------
+# Lightweight JSON-RPC / MCP stdio transport
+# ---------------------------------------------------------------------------
+
+def _jsonrpc_error(req_id: Any, code: int, message: str) -> Dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": req_id, "error": {"code": code, "message": message}}
+
+
+def _jsonrpc_result(req_id: Any, result: Any) -> Dict[str, Any]:
+    return {"jsonrpc": "2.0", "id": req_id, "result": result}
+
+
+def _handle_message(msg: Dict[str, Any]) -> Dict[str, Any] | None:
+    """Process one JSON-RPC message. Returns a response dict, or None for notifications."""
+    method = msg.get("method", "")
+    req_id = msg.get("id")
+    params = msg.get("params", {})
+
+    # --- Lifecycle ----------------------------------------------------------
+    if method == "initialize":
+        return _jsonrpc_result(req_id, {
+            "protocolVersion": _MCP_PROTOCOL_VERSION,
+            "capabilities": {"tools": {}},
+            "serverInfo": {"name": "avrotize", "version": _get_version()},
+        })
+
+    if method == "notifications/initialized":
+        return None  # notification — no response
+
+    if method == "ping":
+        return _jsonrpc_result(req_id, {})
+
+    # --- Tool discovery -----------------------------------------------------
+    if method == "tools/list":
+        return _jsonrpc_result(req_id, {"tools": _tool_schemas()})
+
+    # --- Tool execution -----------------------------------------------------
+    if method == "tools/call":
+        tool_name = params.get("name", "")
+        arguments = params.get("arguments", {})
+        try:
+            result = _dispatch_tool(tool_name, arguments)
+            text = _json.dumps(result, default=str)
+            return _jsonrpc_result(req_id, {
+                "content": [{"type": "text", "text": text}],
+            })
+        except Exception as exc:
+            return _jsonrpc_result(req_id, {
+                "content": [{"type": "text", "text": str(exc)}],
+                "isError": True,
+            })
+
+    # Notifications we don't handle — silently ignore
+    if req_id is None:
+        return None
+
+    return _jsonrpc_error(req_id, -32601, f"Method not found: {method}")
+
+
+def _get_version() -> str:
+    try:
+        from avrotize._version import version
+        return version
+    except Exception:
+        return "dev"
+
+
+def _run_stdio_loop() -> None:
+    """Read JSON-RPC messages from stdin, write responses to stdout."""
+    reader = sys.stdin
+    writer = sys.stdout
+    for line in reader:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            msg = _json.loads(line)
+        except _json.JSONDecodeError:
+            resp = _jsonrpc_error(None, -32700, "Parse error")
+            writer.write(_json.dumps(resp) + "\n")
+            writer.flush()
+            continue
+
+        resp = _handle_message(msg)
+        if resp is not None:
+            writer.write(_json.dumps(resp) + "\n")
+            writer.flush()
+
+
 def run_mcp_server(transport: str = "stdio"):
     """Run avrotize as a local MCP server.
 
-    Exposes conversion tools to MCP clients.
+    Uses a lightweight built-in JSON-RPC stdio implementation by default.
+    """
+    if transport != "stdio":
+        raise ValueError("Only 'stdio' transport is currently supported.")
+    _run_stdio_loop()
+
+
+def run_mcp_server_fastmcp(transport: str = "stdio"):
+    """Run avrotize as a local MCP server using the ``mcp`` library.
+
+    This is slower to start (~2-3 s) because the ``mcp`` library eagerly
+    imports uvicorn, starlette, and httpx.  Kept as a compatibility fallback.
     """
     try:
         from mcp.server.fastmcp import FastMCP
@@ -288,3 +483,16 @@ def run_mcp_server(transport: str = "stdio"):
         mcp.run(transport="stdio")
     except TypeError:
         mcp.run()
+
+
+# ---------------------------------------------------------------------------
+# Direct entry point — bypasses the avrotize CLI argparse overhead.
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    """Entry point for the ``avrotize-mcp`` console script."""
+    run_mcp_server("stdio")
+
+
+if __name__ == "__main__":
+    main()

{structurize-3.4.3 → structurize-3.5.0/structurize.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 3.4.3
+Version: 3.5.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.4.3 → structurize-3.5.0}/structurize.egg-info/SOURCES.txt

@@ -120,6 +120,7 @@ pyproject.toml
 ../avrotize/avrotots/package.json.jinja
 ../avrotize/avrotots/tsconfig.json.jinja
 ../avrotize/dependencies/cpp/vcpkg/vcpkg.json
+../avrotize/dependencies/cs/net100/dependencies.csproj
 ../avrotize/dependencies/cs/net90/dependencies.csproj
 ../avrotize/dependencies/go/go121/go.mod
 ../avrotize/dependencies/java/jdk21/pom.xml