pyrpc-codegen 0.2.0__py3-none-any.whl

pyrpc_codegen/__init__.py

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

pyrpc_codegen/main.py

@@ -0,0 +1,178 @@
+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()

pyrpc_codegen/templates/client.ts.j2

@@ -0,0 +1,22 @@
+/**
+ * @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)
+ * ```
+ */
+
+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/ts_codegen.py

@@ -0,0 +1,115 @@
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict
+
+from jinja2 import Environment, FileSystemLoader
+
+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 _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 name in _TYPE_MAP:
+            return _TYPE_MAP[name]
+        if name[0].isupper():
+            return name
+        return "any"
+
+    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 generate_typescript_client(schemas: Dict[str, Any]) -> str:
+    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)
+
+
+def save_typescript_client(schemas: Dict[str, Any], output_path: str = DEFAULT_OUTPUT):
+    content = generate_typescript_client(schemas)
+    if not os.path.isabs(output_path):
+        output_path = os.path.join(os.getcwd(), output_path)
+    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.2.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+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.dist-info/RECORD

@@ -0,0 +1,8 @@
+pyrpc_codegen/__init__.py,sha256=gljVt_n4DZHclCay30QEIDeAvH0Rt_NEwIFhnHrAyEc,176
+pyrpc_codegen/main.py,sha256=V0V2RDHGs2yz_xLtU-KbVHxRFsEDNP8UvAC1LxcLk4U,5954
+pyrpc_codegen/ts_codegen.py,sha256=xCBJ4j8WhFaXcAsBem3gyHrPqNdUUS3ap9cSDmQ9040,3513
+pyrpc_codegen/templates/client.ts.j2,sha256=S4rMheMaWhP_dxD-7i4yHKWgVGNODC2YS8nOka3QC2E,797
+pyrpc_codegen-0.2.0.dist-info/METADATA,sha256=npYBiBTtLhr9E0EnH05ZAg_AVT5VsVyn9iARxg5rwo8,298
+pyrpc_codegen-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pyrpc_codegen-0.2.0.dist-info/entry_points.txt,sha256=qreeaRwp5UqG0pH4x-0zX8Jsn066ZB3Q8Mp2VeBoUpw,49
+pyrpc_codegen-0.2.0.dist-info/RECORD,,

pyrpc_codegen-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyrpc_codegen-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyrpc = pyrpc_codegen.main:app