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

{pyrpc_codegen-0.7.6 → pyrpc_codegen-0.7.7}/.gitignore

@@ -1,161 +1,163 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-!docs/lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Used for packaging Python scripts into standalone executables
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.stats
-.hypothesis/
-.pytest_cache/
-pytestdebug.log
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   Project-specific python versions
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if Pipfile.lock (and requirements.txt) are not
-#   preferred, then add them into the ignore list.
-# Pipfile.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-# poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-# pdm.lock
-# .pdm-python
-
-# PEP 582; used by e.g. github.com/fannheyward/coc-pyright
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyderformpoint
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# OS X
-.DS_Store
-
-# Node modules
-node_modules
-dist
-
-
-# System design docs (local developer documentation)
-system-design/
-
-# Scripts
-scripts/seed_downloads.py
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+!docs/lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Used for packaging Python scripts into standalone executables
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.stats
+.hypothesis/
+.pytest_cache/
+pytestdebug.log
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   Project-specific python versions
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if Pipfile.lock (and requirements.txt) are not
+#   preferred, then add them into the ignore list.
+# Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+# pdm.lock
+# .pdm-python
+
+# PEP 582; used by e.g. github.com/fannheyward/coc-pyright
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyderformpoint
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# OS X
+.DS_Store
+
+# Node modules
+node_modules
+dist
+
+
+# System design docs (local developer documentation)
+system-design/
+
+# Scripts
+scripts/seed_downloads.py
+# pyrpc client config
+pyrpc-client.json

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

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

{pyrpc_codegen-0.7.6 → pyrpc_codegen-0.7.7}/README.md

@@ -1,21 +1,21 @@
-# pyrpc-codegen
-
-Code generation utilities for [pyRPC](https://pyrpc.com). Generates TypeScript type definitions from Python procedure schemas.
-
-## What it does
-
-- `generate_typescript_client(schemas)` - generates TypeScript interface source code from a schema dict
-- `save_typescript_client(schemas, output_path)` - generates and writes TypeScript types to a file
-- `DEFAULT_OUTPUT` - default output filename constant
-
-## Installation
-
-Installed automatically as a dependency of `pyrpc-core`:
-
-```bash
-uv add pyrpc-core
-```
-
-## License
-
-MIT
+# pyrpc-codegen
+
+Code generation utilities for [pyRPC](https://pyrpc.com). Generates TypeScript type definitions from Python procedure schemas.
+
+## What it does
+
+- `generate_typescript_client(schemas)` - generates TypeScript interface source code from a schema dict
+- `save_typescript_client(schemas, output_path)` - generates and writes TypeScript types to a file
+- `DEFAULT_OUTPUT` - default output filename constant
+
+## Installation
+
+Installed automatically as a dependency of `pyrpc-core`:
+
+```bash
+uv add pyrpc-core
+```
+
+## License
+
+MIT

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

@@ -1,16 +1,16 @@
-[project]
-name = "pyrpc-codegen"
-version = "0.7.6"
-description = "Codegen and CLI tools for pyRPC"
-requires-python = ">=3.11"
-dependencies = [
-    "jinja2>=3.1.0",
-    "jsonschema-ts>=0.2.0",
-]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/pyrpc_codegen"]
+[project]
+name = "pyrpc-codegen"
+version = "0.7.7"
+description = "Codegen and CLI tools for pyRPC"
+requires-python = ">=3.11"
+dependencies = [
+    "jinja2>=3.1.0",
+    "jsonschema-ts>=0.2.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyrpc_codegen"]

{pyrpc_codegen-0.7.6 → pyrpc_codegen-0.7.7}/src/pyrpc_codegen/__init__.py

@@ -1,3 +1,3 @@
-from .ts_codegen import DEFAULT_OUTPUT, generate_typescript_client, save_typescript_client
-
-__all__ = ["DEFAULT_OUTPUT", "generate_typescript_client", "save_typescript_client"]
+from .ts_codegen import DEFAULT_OUTPUT, generate_typescript_client, save_typescript_client
+
+__all__ = ["DEFAULT_OUTPUT", "generate_typescript_client", "save_typescript_client"]

{pyrpc_codegen-0.7.6 → pyrpc_codegen-0.7.7}/src/pyrpc_codegen/templates/client.ts.j2

@@ -1,24 +1,24 @@
-/**
- * @pyrpc/types - Auto-generated by `pyrpc codegen`.
- * @see https://pyrpc.io/docs/plugins/prpc-codegen
- *
- * Import `Types` and pass to `createClient<Types>()` for full type safety.
- *
- * ```ts
- * import { createClient } from "@pyrpc/client"
- * import type { Types } from "@pyrpc/types"
- * const client = createClient<Types>({ baseUrl: "https://..." })
- * const result = await client.someProcedure(42)
- * ```
- */
-/* eslint-disable */
-
-// ── Procedures ──────────────────────────────────────────
-export interface Types {
-  {% for name, schema in schemas.items() %}
-  /**
-   * {{ schema.doc or "No documentation available." }}
-   */
-  {{ name }}({% for param in schema.parameters %}{{ param.name }}: {{ param.type | pytype_to_ts }}{% if not loop.last %}, {% endif %}{% endfor %}): Promise<{{ schema.return_type | return_type_to_ts }}>;
-  {% endfor %}
-}
+/**
+ * @pyrpc/types - Auto-generated by `pyrpc codegen`.
+ * @see https://pyrpc.io/docs/plugins/prpc-codegen
+ *
+ * Import `Types` and pass to `createClient<Types>()` for full type safety.
+ *
+ * ```ts
+ * import { createClient } from "@pyrpc/client"
+ * import type { Types } from "@pyrpc/types"
+ * const client = createClient<Types>({ baseUrl: "https://..." })
+ * const result = await client.someProcedure(42)
+ * ```
+ */
+/* eslint-disable */
+
+// ── Procedures ──────────────────────────────────────────
+export interface Types {
+  {% for name, schema in schemas.items() %}
+  /**
+   * {{ schema.doc or "No documentation available." }}
+   */
+  {{ name }}({% for param in schema.parameters %}{{ param.name }}: {{ param.type | pytype_to_ts }}{% if not loop.last %}, {% endif %}{% endfor %}): Promise<{{ schema.return_type | return_type_to_ts }}>;
+  {% endfor %}
+}

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

@@ -1,182 +1,182 @@
-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, ensure_inline_models
-
-DEFAULT_OUTPUT = "node_modules/@pyrpc/types/src/index.ts"
-
-_TYPE_MAP: Dict[str, str] = {
-    "int": "number",
-    "float": "number",
-    "str": "string",
-    "bool": "boolean",
-    "None": "null",
-    "NoneType": "null",
-    "Any": "any",
-}
-
-
-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"
-
-    m = re.match(r"<class\s+'([^']+)'>", type_str)
-    if m:
-        name = m.group(1)
-        if '.' in name:
-            name = name.rsplit('.', 1)[1]
-        if name in _TYPE_MAP:
-            return _TYPE_MAP[name]
-        return _to_safe_name(name)
-
-    if type_str.startswith("typing."):
-        type_str = type_str[7:]
-
-    if type_str.startswith("Optional["):
-        inner = type_str[9:-1]
-        return f"{_pytype_to_ts(inner)} | null"
-
-    if type_str.startswith("Union["):
-        inner = type_str[6:-1]
-        parts = _split_type_args(inner)
-        ts_parts = [_pytype_to_ts(p.strip()) for p in parts]
-        non_null = [p for p in ts_parts if p != "null"]
-        if len(non_null) < len(ts_parts):
-            return f"{' | '.join(non_null)} | null"
-        return " | ".join(ts_parts)
-
-    if type_str.startswith("List[") or type_str.startswith("list["):
-        inner = type_str[5:-1]
-        return f"{_pytype_to_ts(inner.strip())}[]"
-
-    if type_str.startswith("Dict[") or type_str.startswith("dict["):
-        inner = type_str[5:-1]
-        parts = _split_type_args(inner)
-        if len(parts) >= 2:
-            return f"Record<{_pytype_to_ts(parts[0].strip())}, {_pytype_to_ts(parts[1].strip())}>"
-        return "Record<string, any>"
-
-    if type_str.startswith("Tuple[") or type_str.startswith("tuple["):
-        inner = type_str[6:-1]
-        parts = _split_type_args(inner)
-        ts_parts = [_pytype_to_ts(p.strip()) for p in parts]
-        return f"[{', '.join(ts_parts)}]"
-
-    if type_str.startswith("Set[") or type_str.startswith("set["):
-        inner = type_str[4:-1]
-        return f"Set<{_pytype_to_ts(inner.strip())}>"
-
-    return "any"
-
-
-def _split_type_args(s: str) -> list:
-    parts = []
-    depth = 0
-    current = ""
-    for c in s:
-        if c in "[(":
-            depth += 1
-            current += c
-        elif c in "])":
-            depth -= 1
-            current += c
-        elif c == "," and depth == 0:
-            parts.append(current)
-            current = ""
-        else:
-            current += c
-    if current:
-        parts.append(current)
-    return parts
-
-
-def _return_type_to_ts(return_type: str) -> str:
-    return _pytype_to_ts(return_type)
-
-
-def _collect_schema_defs(schemas: Dict[str, Any]) -> dict:
-    schema_sources = []
-    for _name, schema in schemas.items():
-        if isinstance(schema, dict):
-            params = schema.get("parameters", [])
-        else:
-            params = schema.parameters
-        for param in params:
-            if isinstance(param, dict):
-                js = param.get("schema") or param.get("schema_")
-            else:
-                js = param.schema_
-            if js:
-                schema_sources.append(js)
-        if isinstance(schema, dict):
-            rs = schema.get("return_schema")
-        else:
-            rs = schema.return_schema
-        if rs:
-            schema_sources.append(rs)
-
-    processed = ensure_inline_models(*schema_sources)
-    return collect_defs(*processed)
-
-
-def generate_typescript_client(schemas: Dict[str, Any]) -> str:
-    defs = _collect_schema_defs(schemas)
-
-    opts = JsonschemaTsOptions(
-        banner_comment="",
-        format=True,
-        unknown_any=True,
-    )
-
-    model_interfaces = convert_all(defs, opts=opts)
-
-    template_dir = Path(__file__).parent / "templates"
-    env = Environment(loader=FileSystemLoader(template_dir))
-    env.filters["pytype_to_ts"] = _pytype_to_ts
-    env.filters["return_type_to_ts"] = _return_type_to_ts
-    template = env.get_template("client.ts.j2")
-
-    procedure_types = template.render(schemas=schemas)
-
-    return assemble(
-        models=model_interfaces,
-        procedures=procedure_types,
-        banner="",
-    )
-
-
-def save_typescript_client(schemas: Dict[str, Any], output_path: str):
-    if not os.path.isabs(output_path):
-        raise ValueError(
-            "save_typescript_client requires an absolute path"
-        )
-    content = generate_typescript_client(schemas)
-    os.makedirs(os.path.dirname(output_path), exist_ok=True)
-    with open(output_path, "w", encoding="utf-8") as f:
-        f.write(content)
+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, ensure_inline_models
+
+DEFAULT_OUTPUT = "node_modules/@pyrpc/types/src/index.ts"
+
+_TYPE_MAP: Dict[str, str] = {
+    "int": "number",
+    "float": "number",
+    "str": "string",
+    "bool": "boolean",
+    "None": "null",
+    "NoneType": "null",
+    "Any": "any",
+}
+
+
+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"
+
+    m = re.match(r"<class\s+'([^']+)'>", type_str)
+    if m:
+        name = m.group(1)
+        if '.' in name:
+            name = name.rsplit('.', 1)[1]
+        if name in _TYPE_MAP:
+            return _TYPE_MAP[name]
+        return _to_safe_name(name)
+
+    if type_str.startswith("typing."):
+        type_str = type_str[7:]
+
+    if type_str.startswith("Optional["):
+        inner = type_str[9:-1]
+        return f"{_pytype_to_ts(inner)} | null"
+
+    if type_str.startswith("Union["):
+        inner = type_str[6:-1]
+        parts = _split_type_args(inner)
+        ts_parts = [_pytype_to_ts(p.strip()) for p in parts]
+        non_null = [p for p in ts_parts if p != "null"]
+        if len(non_null) < len(ts_parts):
+            return f"{' | '.join(non_null)} | null"
+        return " | ".join(ts_parts)
+
+    if type_str.startswith("List[") or type_str.startswith("list["):
+        inner = type_str[5:-1]
+        return f"{_pytype_to_ts(inner.strip())}[]"
+
+    if type_str.startswith("Dict[") or type_str.startswith("dict["):
+        inner = type_str[5:-1]
+        parts = _split_type_args(inner)
+        if len(parts) >= 2:
+            return f"Record<{_pytype_to_ts(parts[0].strip())}, {_pytype_to_ts(parts[1].strip())}>"
+        return "Record<string, any>"
+
+    if type_str.startswith("Tuple[") or type_str.startswith("tuple["):
+        inner = type_str[6:-1]
+        parts = _split_type_args(inner)
+        ts_parts = [_pytype_to_ts(p.strip()) for p in parts]
+        return f"[{', '.join(ts_parts)}]"
+
+    if type_str.startswith("Set[") or type_str.startswith("set["):
+        inner = type_str[4:-1]
+        return f"Set<{_pytype_to_ts(inner.strip())}>"
+
+    return "any"
+
+
+def _split_type_args(s: str) -> list:
+    parts = []
+    depth = 0
+    current = ""
+    for c in s:
+        if c in "[(":
+            depth += 1
+            current += c
+        elif c in "])":
+            depth -= 1
+            current += c
+        elif c == "," and depth == 0:
+            parts.append(current)
+            current = ""
+        else:
+            current += c
+    if current:
+        parts.append(current)
+    return parts
+
+
+def _return_type_to_ts(return_type: str) -> str:
+    return _pytype_to_ts(return_type)
+
+
+def _collect_schema_defs(schemas: Dict[str, Any]) -> dict:
+    schema_sources = []
+    for _name, schema in schemas.items():
+        if isinstance(schema, dict):
+            params = schema.get("parameters", [])
+        else:
+            params = schema.parameters
+        for param in params:
+            if isinstance(param, dict):
+                js = param.get("schema") or param.get("schema_")
+            else:
+                js = param.schema_
+            if js:
+                schema_sources.append(js)
+        if isinstance(schema, dict):
+            rs = schema.get("return_schema")
+        else:
+            rs = schema.return_schema
+        if rs:
+            schema_sources.append(rs)
+
+    processed = ensure_inline_models(*schema_sources)
+    return collect_defs(*processed)
+
+
+def generate_typescript_client(schemas: Dict[str, Any]) -> str:
+    defs = _collect_schema_defs(schemas)
+
+    opts = JsonschemaTsOptions(
+        banner_comment="",
+        format=True,
+        unknown_any=True,
+    )
+
+    model_interfaces = convert_all(defs, opts=opts)
+
+    template_dir = Path(__file__).parent / "templates"
+    env = Environment(loader=FileSystemLoader(template_dir))
+    env.filters["pytype_to_ts"] = _pytype_to_ts
+    env.filters["return_type_to_ts"] = _return_type_to_ts
+    template = env.get_template("client.ts.j2")
+
+    procedure_types = template.render(schemas=schemas)
+
+    return assemble(
+        models=model_interfaces,
+        procedures=procedure_types,
+        banner="",
+    )
+
+
+def save_typescript_client(schemas: Dict[str, Any], output_path: str):
+    if not os.path.isabs(output_path):
+        raise ValueError(
+            "save_typescript_client requires an absolute path"
+        )
+    content = generate_typescript_client(schemas)
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(content)

{pyrpc_codegen-0.7.6 → pyrpc_codegen-0.7.7}/tests/test_codegen.py

@@ -1,255 +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
+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