pyrpc-codegen 0.7.4__tar.gz → 0.7.6__tar.gz

{pyrpc_codegen-0.7.4 → pyrpc_codegen-0.7.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pyrpc-codegen
-Version: 0.7.4
+Version: 0.7.6
 Summary: Codegen and CLI tools for pyRPC
 Requires-Python: >=3.11
 Requires-Dist: jinja2>=3.1.0
-Requires-Dist: jsonschema-ts>=0.1.0
+Requires-Dist: jsonschema-ts>=0.2.0

{pyrpc_codegen-0.7.4 → pyrpc_codegen-0.7.6}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "pyrpc-codegen"
-version = "0.7.4"
+version = "0.7.6"
 description = "Codegen and CLI tools for pyRPC"
 requires-python = ">=3.11"
 dependencies = [
     "jinja2>=3.1.0",
-    "jsonschema-ts>=0.1.0",
+    "jsonschema-ts>=0.2.0",
 ]
 
 [build-system]

{pyrpc_codegen-0.7.4 → pyrpc_codegen-0.7.6}/src/pyrpc_codegen/ts_codegen.py

@@ -1,11 +1,12 @@
 import os
 import re
+import unicodedata
 from pathlib import Path
 from typing import Any, Dict
 
 from jinja2 import Environment, FileSystemLoader
 from jsonschema_ts import Options as JsonschemaTsOptions
-from jsonschema_ts import assemble, collect_defs, convert_all
+from jsonschema_ts import assemble, collect_defs, convert_all, ensure_inline_models
 
 DEFAULT_OUTPUT = "node_modules/@pyrpc/types/src/index.ts"
 
@@ -20,6 +21,27 @@ _TYPE_MAP: Dict[str, str] = {
 }
 
 
+def _to_safe_name(name: str) -> str:
+    s = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode("ascii")
+    s = re.sub(r"[^a-zA-Z0-9]", " ", s)
+    s = _to_pascal_case(s)
+    return s or "GeneratedType"
+
+
+def _to_pascal_case(s: str) -> str:
+    parts = s.split()
+    result: list[str] = []
+    for part in parts:
+        sub_parts = re.findall(
+            r"[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\b)|[A-Z]+|\d+",
+            part,
+        )
+        if not sub_parts:
+            sub_parts = [part]
+        result.extend(sub_parts)
+    return "".join(seg.capitalize() for seg in result if seg)
+
+
 def _pytype_to_ts(type_str: str) -> str:
     if not type_str:
         return "any"
@@ -31,7 +53,7 @@ def _pytype_to_ts(type_str: str) -> str:
             name = name.rsplit('.', 1)[1]
         if name in _TYPE_MAP:
             return _TYPE_MAP[name]
-        return name
+        return _to_safe_name(name)
 
     if type_str.startswith("typing."):
         type_str = type_str[7:]
@@ -106,13 +128,21 @@ def _collect_schema_defs(schemas: Dict[str, Any]) -> dict:
         else:
             params = schema.parameters
         for param in params:
-            js = param.get("schema") if isinstance(param, dict) else param.schema_
+            if isinstance(param, dict):
+                js = param.get("schema") or param.get("schema_")
+            else:
+                js = param.schema_
             if js:
                 schema_sources.append(js)
-        rs = schema.get("return_schema") if isinstance(schema, dict) else schema.return_schema
+        if isinstance(schema, dict):
+            rs = schema.get("return_schema")
+        else:
+            rs = schema.return_schema
         if rs:
             schema_sources.append(rs)
-    return collect_defs(*schema_sources)
+
+    processed = ensure_inline_models(*schema_sources)
+    return collect_defs(*processed)
 
 
 def generate_typescript_client(schemas: Dict[str, Any]) -> str:

pyrpc_codegen-0.7.6/tests/test_codegen.py

@@ -0,0 +1,255 @@
+import json
+import os
+import shutil
+import tempfile
+import pytest
+from pydantic import BaseModel
+from pydantic.dataclasses import dataclass
+from pyrpc_core import rpc, default_router, get_registry_schema
+from pyrpc_codegen import generate_typescript_client, save_typescript_client
+from pyrpc_codegen.ts_codegen import _to_safe_name, _to_pascal_case, _collect_schema_defs
+
+def _npx_works() -> bool:
+    """Check if npx works via subprocess.run without shell=True (how jsonschema_ts calls it)."""
+    path = shutil.which("npx")
+    if not path:
+        return False
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["npx", "--version"],
+            capture_output=True, text=True, timeout=5, shell=False,
+        )
+        return result.returncode == 0
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+npx_available = _npx_works()
+
+
+@pytest.fixture(autouse=True)
+def clear_registry():
+    default_router._procedures.clear()
+
+
+def test_generate_typescript_client():
+    @rpc
+    def add(a: int, b: int) -> int:
+        """Add two numbers."""
+        return a + b
+
+    schemas = get_registry_schema(default_router)
+    content = generate_typescript_client(schemas)
+
+    assert "export interface Types" in content
+    assert "add(a: number, b: number): Promise<number>;" in content
+
+
+def test_generate_typescript_client_empty():
+    schemas = get_registry_schema(default_router)
+    content = generate_typescript_client(schemas)
+    assert "export interface Types {" in content
+
+
+def test_save_typescript_client_from_file():
+    schemas = {
+        "greet": {
+            "name": "greet",
+            "doc": "Say hello",
+            "parameters": [
+                {"name": "name", "type": "<class 'str'>", "required": True, "default": None}
+            ],
+            "return_type": "<class 'str'>",
+        }
+    }
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        schema_file = os.path.join(tmpdir, "schema.json")
+        with open(schema_file, "w") as f:
+            json.dump(schemas, f)
+
+        from pyrpc_core.cli import _load_schema
+        loaded = _load_schema(schema_file)
+        assert loaded == schemas
+
+        output_file = os.path.join(tmpdir, "types.ts")
+        save_typescript_client(schemas, output_file)
+
+        with open(output_file) as f:
+            content = f.read()
+
+        assert "export interface Types" in content
+        assert "greet(name: string): Promise<string>;" in content
+
+
+def test_save_typescript_client_serialized_schema():
+    @rpc
+    def add(a: int) -> int:
+        return a
+
+    schemas = get_registry_schema(default_router)
+
+    serializable = {}
+    for name, schema in schemas.items():
+        serializable[name] = {
+            "name": schema.name,
+            "doc": schema.doc or "",
+            "parameters": [
+                {"name": p.name, "type": p.type, "required": p.required, "default": p.default}
+                for p in schema.parameters
+            ],
+            "return_type": schema.return_type,
+        }
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        output_file = os.path.join(tmpdir, "types.ts")
+        save_typescript_client(serializable, output_file)
+
+        with open(output_file) as f:
+            content = f.read()
+
+        assert "export interface Types" in content
+        assert "add(a: number): Promise<number>;" in content
+
+
+def test_to_pascal_case():
+    assert _to_pascal_case("User") == "User"
+    assert _to_pascal_case("user") == "User"
+    assert _to_pascal_case("MyClass") == "MyClass"
+    assert _to_pascal_case("my_model") == "MyModel"
+    assert _to_pascal_case("") == ""
+
+
+def test_to_safe_name():
+    assert _to_safe_name("User") == "User"
+    assert _to_safe_name("my_model") == "MyModel"
+    assert _to_safe_name("MyClass") == "MyClass"
+    assert _to_safe_name("") == "GeneratedType"
+
+
+def test_collect_defs_base_model():
+    class UserModel(BaseModel):
+        name: str
+        age: int
+
+    @rpc
+    def get_user(u: UserModel) -> UserModel:
+        return u
+
+    schemas = get_registry_schema(default_router)
+    defs = _collect_schema_defs(schemas)
+    assert "UserModel" in defs
+
+
+def test_collect_defs_at_model():
+    @dataclass
+    class Item:
+        name: str
+        price: float
+
+    @rpc
+    def buy(item: Item) -> Item:
+        return item
+
+    schemas = get_registry_schema(default_router)
+    defs = _collect_schema_defs(schemas)
+    assert "Item" in defs
+
+
+def test_collect_defs_nested_base_model():
+    class Address(BaseModel):
+        city: str
+        zip: str
+
+    class UserNested(BaseModel):
+        name: str
+        address: Address
+
+    @rpc
+    def get_user(u: UserNested) -> UserNested:
+        return u
+
+    schemas = get_registry_schema(default_router)
+    defs = _collect_schema_defs(schemas)
+    assert "UserNested" in defs
+    assert "Address" in defs
+
+
+def test_collect_defs_nested_at_model():
+    @dataclass
+    class Address:
+        city: str
+        zip: str
+
+    @dataclass
+    class Person:
+        name: str
+        address: Address
+
+    @rpc
+    def get_person(p: Person) -> Person:
+        return p
+
+    schemas = get_registry_schema(default_router)
+    defs = _collect_schema_defs(schemas)
+    assert "Person" in defs
+    assert "Address" in defs
+
+
+def test_collect_defs_nested_mixed():
+    class Address(BaseModel):
+        city: str
+        zip: str
+
+    @dataclass
+    class Person:
+        name: str
+        address: Address
+
+    class Organization(BaseModel):
+        name: str
+        owner: Person
+
+    @rpc
+    def get_org(o: Organization) -> Organization:
+        return o
+
+    schemas = get_registry_schema(default_router)
+    defs = _collect_schema_defs(schemas)
+    assert "Organization" in defs
+    assert "Person" in defs
+    assert "Address" in defs
+
+
+@pytest.mark.skipif(not npx_available, reason="requires npx (json-schema-to-typescript)")
+def test_generate_typescript_client_with_base_model():
+    class UserModel(BaseModel):
+        name: str
+        age: int
+        email: str
+
+    @rpc
+    def create_user(user: UserModel) -> UserModel:
+        return user
+
+    schemas = get_registry_schema(default_router)
+    content = generate_typescript_client(schemas)
+    assert "export interface Types" in content
+    assert "UserModel" in content
+
+
+@pytest.mark.skipif(not npx_available, reason="requires npx (json-schema-to-typescript)")
+def test_generate_typescript_client_with_at_model():
+    @dataclass
+    class Item:
+        name: str
+        price: float
+
+    @rpc
+    def buy_item(item: Item) -> Item:
+        return item
+
+    schemas = get_registry_schema(default_router)
+    content = generate_typescript_client(schemas)
+    assert "export interface Types" in content
+    assert "Item" in content

pyrpc_codegen-0.7.4/tests/test_codegen.py

@@ -1,91 +0,0 @@
-import json
-import os
-import tempfile
-import pytest
-from pyrpc_core import rpc, default_router, get_registry_schema
-from pyrpc_codegen import generate_typescript_client, save_typescript_client
-
-
-@pytest.fixture(autouse=True)
-def clear_registry():
-    default_router._procedures.clear()
-
-
-def test_generate_typescript_client():
-    @rpc
-    def add(a: int, b: int) -> int:
-        """Add two numbers."""
-        return a + b
-
-    schemas = get_registry_schema(default_router)
-    content = generate_typescript_client(schemas)
-
-    assert "export interface Types" in content
-    assert "add(a: number, b: number): Promise<number>;" in content
-
-
-def test_generate_typescript_client_empty():
-    schemas = get_registry_schema(default_router)
-    content = generate_typescript_client(schemas)
-    assert "export interface Types {" in content
-
-
-def test_save_typescript_client_from_file():
-    schemas = {
-        "greet": {
-            "name": "greet",
-            "doc": "Say hello",
-            "parameters": [
-                {"name": "name", "type": "<class 'str'>", "required": True, "default": None}
-            ],
-            "return_type": "<class 'str'>",
-        }
-    }
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        schema_file = os.path.join(tmpdir, "schema.json")
-        with open(schema_file, "w") as f:
-            json.dump(schemas, f)
-
-        from pyrpc_core.cli import _load_schema
-        loaded = _load_schema(schema_file)
-        assert loaded == schemas
-
-        output_file = os.path.join(tmpdir, "types.ts")
-        save_typescript_client(schemas, output_file)
-
-        with open(output_file) as f:
-            content = f.read()
-
-        assert "export interface Types" in content
-        assert "greet(name: string): Promise<string>;" in content
-
-
-def test_save_typescript_client_serialized_schema():
-    @rpc
-    def add(a: int) -> int:
-        return a
-
-    schemas = get_registry_schema(default_router)
-
-    serializable = {}
-    for name, schema in schemas.items():
-        serializable[name] = {
-            "name": schema.name,
-            "doc": schema.doc or "",
-            "parameters": [
-                {"name": p.name, "type": p.type, "required": p.required, "default": p.default}
-                for p in schema.parameters
-            ],
-            "return_type": schema.return_type,
-        }
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        output_file = os.path.join(tmpdir, "types.ts")
-        save_typescript_client(serializable, output_file)
-
-        with open(output_file) as f:
-            content = f.read()
-
-        assert "export interface Types" in content
-        assert "add(a: number): Promise<number>;" in content