pyrpc-codegen 0.2.0__tar.gz → 0.3.1__tar.gz

{pyrpc_codegen-0.2.0 → pyrpc_codegen-0.3.1}/.gitignore

@@ -152,3 +152,7 @@ cython_debug/
 # Node modules
 node_modules
 dist
+
+
+# System design docs (local developer documentation)
+system-design/

pyrpc_codegen-0.3.1/PKG-INFO

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

{pyrpc_codegen-0.2.0 → pyrpc_codegen-0.3.1}/pyproject.toml

@@ -1,20 +1,13 @@
 [project]
 name = "pyrpc-codegen"
-version = "0.2.0"
+version = "0.3.1"
 description = "Codegen and CLI tools for pyRPC"
 requires-python = ">=3.11"
 dependencies = [
-    "pyrpc-core",
-    "typer[all]>=0.9.0",
-    "rich>=13.0.0",
     "jinja2>=3.1.0",
-    "uvicorn>=0.23.0",
-    "httpx>=0.28.1",
+    "jsonschema-ts>=0.1.0",
 ]
 
-[project.scripts]
-pyrpc = "pyrpc_codegen.main:app"
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

pyrpc_codegen-0.3.1/src/pyrpc_codegen/__init__.py

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

{pyrpc_codegen-0.2.0 → pyrpc_codegen-0.3.1}/src/pyrpc_codegen/templates/client.ts.j2

@@ -11,7 +11,9 @@
  * const result = await client.someProcedure(42)
  * ```
  */
+/* eslint-disable */
 
+// ── Procedures ──────────────────────────────────────────
 export interface Types {
   {% for name, schema in schemas.items() %}
   /**

{pyrpc_codegen-0.2.0 → pyrpc_codegen-0.3.1}/src/pyrpc_codegen/ts_codegen.py

@@ -4,6 +4,8 @@ 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
 
 DEFAULT_OUTPUT = "node_modules/@pyrpc/types/src/index.ts"
 
@@ -96,14 +98,47 @@ 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:
+            js = param.get("schema") if isinstance(param, dict) else param.schema_
+            if js:
+                schema_sources.append(js)
+        rs = schema.get("return_schema") if isinstance(schema, dict) else schema.return_schema
+        if rs:
+            schema_sources.append(rs)
+    return collect_defs(*schema_sources)
+
+
 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")
 
-    return template.render(schemas=schemas)
+    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 = DEFAULT_OUTPUT):

pyrpc_codegen-0.2.0/PKG-INFO

@@ -1,11 +0,0 @@
-Metadata-Version: 2.4
-Name: pyrpc-codegen
-Version: 0.2.0
-Summary: Codegen and CLI tools for pyRPC
-Requires-Python: >=3.11
-Requires-Dist: httpx>=0.28.1
-Requires-Dist: jinja2>=3.1.0
-Requires-Dist: pyrpc-core
-Requires-Dist: rich>=13.0.0
-Requires-Dist: typer[all]>=0.9.0
-Requires-Dist: uvicorn>=0.23.0

pyrpc_codegen-0.2.0/src/pyrpc_codegen/__init__.py

@@ -1,4 +0,0 @@
-from .ts_codegen import generate_typescript_client, save_typescript_client
-from .main import app
-
-__all__ = ["generate_typescript_client", "save_typescript_client", "app"]

pyrpc_codegen-0.2.0/src/pyrpc_codegen/main.py

@@ -1,178 +0,0 @@
-import importlib
-import json
-import os
-import sys
-
-import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-
-from .ts_codegen import save_typescript_client, DEFAULT_OUTPUT
-
-
-__version__ = "0.2.0"
-
-
-app = typer.Typer(
-    name="pyrpc",
-    help="pyRPC CLI - type-safe Python-to-TypeScript RPC",
-    add_completion=False,
-)
-console = Console()
-
-
-def _lazy_import_pyrpc_core():
-    """Import pyrpc-core lazily so codegen-only usage avoids the dep."""
-    global default_router, get_registry_schema
-    from pyrpc_core import default_router, get_registry_schema
-    return default_router, get_registry_schema
-
-
-def _import_module(module_path: str):
-    sys.path.append(os.getcwd())
-    try:
-        return importlib.import_module(module_path)
-    except ImportError as e:
-        console.print(f"[bold red]Error:[/bold red] Could not import module '{module_path}': {e}")
-        raise typer.Exit(code=1)
-
-
-def _fetch_schema(url: str) -> dict:
-    import httpx
-    clean_url = url.rstrip("/")
-    if not clean_url.endswith("/rpc"):
-        clean_url += "/rpc"
-    response = httpx.get(clean_url)
-    response.raise_for_status()
-    return response.json()
-
-
-def _load_schema(path_or_url: str) -> dict:
-    if path_or_url.startswith("http://") or path_or_url.startswith("https://"):
-        console.print(f"Fetching schema from [bold yellow]{path_or_url}[/bold yellow]...")
-        return _fetch_schema(path_or_url)
-    path = os.path.abspath(path_or_url)
-    console.print(f"Reading schema from [bold yellow]{path}[/bold yellow]...")
-    with open(path, "r") as f:
-        return json.load(f)
-
-
-@app.command()
-def version():
-    """Show pyRPC version."""
-    console.print(f"pyRPC version: [bold cyan]{__version__}[/bold cyan]")
-
-
-@app.command()
-def pull(
-    module: str = typer.Argument(..., help="Python module path (e.g. 'app.main')"),
-    output: str = typer.Option("pyrpc-schema.json", "--output", "-o", help="Output JSON schema file path"),
-):
-    """Extract RPC schema from a Python module and save as JSON."""
-    _lazy_import_pyrpc_core()
-    _import_module(module)
-
-    schemas = get_registry_schema(default_router)
-
-    if not schemas:
-        console.print("[yellow]No procedures found in registry for this module.[/yellow]")
-        raise typer.Exit(code=1)
-
-    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,
-        }
-
-    output_path = os.path.abspath(output)
-    os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
-    with open(output_path, "w") as f:
-        json.dump(serializable, f, indent=2)
-
-    console.print(f"[bold green]OK Schema extracted to {output_path}[/bold green]")
-    console.print(f"  ({len(serializable)} procedure(s) written)")
-
-
-@app.command()
-def serve(
-    module: str = typer.Argument(..., help="Module containing the pyRPC application (e.g. 'app.main')"),
-    host: str = typer.Option("127.0.0.1", "--host", "-h", help="Bind socket to this host"),
-    port: int = typer.Option(8000, "--port", "-p", help="Bind socket to this port"),
-    reload: bool = typer.Option(False, "--reload", help="Enable auto-reload"),
-):
-    """Start the pyRPC ASGI server."""
-    _lazy_import_pyrpc_core()
-    import uvicorn
-    _import_module(module)
-
-    console.print(Panel(
-        f"Starting pyRPC server for [bold cyan]{module}[/bold cyan]\n"
-        f"Endpoint: [bold green]http://{host}:{port}/rpc[/bold green]",
-        title="pyRPC Serve",
-        border_style="blue"
-    ))
-
-    uvicorn.run("pyrpc:asgi_app", host=host, port=port, reload=reload)
-
-
-@app.command()
-def codegen(
-    source: str = typer.Argument(..., help="Schema JSON file path or URL of a running pyRPC server (e.g. pyrpc-schema.json or http://localhost:8000)"),
-    output: str = typer.Option(DEFAULT_OUTPUT, "--output", "-o", help="Output file path for generated types"),
-):
-    """Generate TypeScript type definitions from a schema file or a running server."""
-    try:
-        schemas = _load_schema(source)
-    except Exception as e:
-        console.print(f"[bold red]Error:[/bold red] Could not load schema from '{source}': {e}")
-        raise typer.Exit(code=1)
-
-    console.print(f"Generating TypeScript contracts [dim]({len(schemas)} procedures)[/dim]...")
-    save_typescript_client(schemas, output)
-    console.print(f"[bold green]OK Types written to {output}[/bold green]")
-
-    if os.path.exists(output):
-        console.print(f"  Import: [bold]import type {{ Types }} from \"@pyrpc/types\"[/bold]")
-
-
-@app.command()
-def inspect(
-    module: str = typer.Argument(..., help="Module to inspect")
-):
-    """List all registered RPC procedures in a module."""
-    _lazy_import_pyrpc_core()
-    _import_module(module)
-
-    schemas = get_registry_schema(default_router)
-
-    if not schemas:
-        console.print("[yellow]No procedures found in registry for this module.[/yellow]")
-        return
-
-    table = Table(title=f"pyRPC Registry: {module}")
-    table.add_column("Method", style="cyan")
-    table.add_column("Params", style="green")
-    table.add_column("Returns", style="magenta")
-    table.add_column("Doc", style="white", no_wrap=False)
-
-    for name, schema in schemas.items():
-        params = ", ".join([f"{p.name}: {p.type}" for p in schema.parameters])
-        table.add_row(
-            name,
-            params or "None",
-            schema.return_type,
-            schema.doc or ""
-        )
-
-    console.print(table)
-
-
-if __name__ == "__main__":
-    app()