pyrpc-codegen 0.2.0__tar.gz

pyrpc_codegen-0.2.0/.gitignore

@@ -0,0 +1,154 @@
+# 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

pyrpc_codegen-0.2.0/PKG-INFO

@@ -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/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "pyrpc-codegen"
+version = "0.2.0"
+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",
+]
+
+[project.scripts]
+pyrpc = "pyrpc_codegen.main:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyrpc_codegen"]

pyrpc_codegen-0.2.0/src/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-0.2.0/src/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-0.2.0/src/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-0.2.0/src/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)