dyadpy 0.1.0a0__tar.gz

dyadpy-0.1.0a0/.gitignore

@@ -0,0 +1,107 @@
+# ---- OS ----
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# ---- Editors ----
+.idea/
+*.swp
+*.swo
+*~
+.vscode/*
+!.vscode/settings.json
+!.vscode/extensions.json
+!.vscode/launch.json
+
+# ---- Node ----
+node_modules/
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+.npm/
+.eslintcache
+.oxlintcache
+*.tsbuildinfo
+next-env.d.ts
+
+# ---- Build output ----
+dist/
+build/
+out/
+.next/
+.turbo/
+.vercel/
+.cache/
+coverage/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# ---- Python ----
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.python-version-local
+.venv/
+venv/
+env/
+ENV/
+.uv-cache/
+.eggs/
+*.egg-info/
+*.egg
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+.hypothesis/
+*.cover
+*.py,cover
+
+# ---- Claude Code harness ----
+.claude/
+!.claude/settings.json
+!.claude/commands/
+
+# ---- Dyadpy ----
+.dyadpy/
+# Generated TS clients in examples are gitignored;
+# regenerated on dev. Comment out if you want them committed.
+**/lib/dyadpy/client.ts
+
+# ---- Benchmarks ----
+benchmarks/results/
+benchmarks/uv.lock
+
+# ---- SvelteKit generated ----
+# Everything is regenerated on ``pnpm dev`` / ``svelte-kit sync``. We commit
+# just the tsconfig.json so editor TypeScript diagnostics don't break on a
+# fresh clone before the first sync has run.
+**/.svelte-kit/*
+!**/.svelte-kit/tsconfig.json
+
+# ---- Env / secrets ----
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+*.crt
+
+# ---- Misc ----
+*.tgz
+*.zip
+.DS_Store?
+._*

dyadpy-0.1.0a0/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog · `dyadpy`
+
+All notable changes to the `dyadpy` Python package will be documented in this
+file. Managed automatically by [release-please](https://github.com/googleapis/release-please)
+from [Conventional Commits](https://www.conventionalcommits.org/).
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Initial package scaffold: `App`, route decorators, `Context`,
+  `Depends`, `stream`, `@raises`, IR builder, codegen renderer, `dyadpy`
+  CLI.

dyadpy-0.1.0a0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: dyadpy
+Version: 0.1.0a0
+Summary: A type-safe RPC bridge between Python and TypeScript. The function signature is the contract.
+Project-URL: Homepage, https://github.com/tamimbinhakim/dyadpy
+Project-URL: Documentation, https://github.com/tamimbinhakim/dyadpy/tree/main/docs
+Project-URL: Repository, https://github.com/tamimbinhakim/dyadpy
+Project-URL: Issues, https://github.com/tamimbinhakim/dyadpy/issues
+Project-URL: Changelog, https://github.com/tamimbinhakim/dyadpy/blob/main/packages/dyadpy/CHANGELOG.md
+Author-email: Tamim Bin Hakim <tamimbinhakim@users.noreply.github.com>
+License: MIT
+Keywords: asgi,codegen,fastapi-alternative,msgspec,rpc,sse,streaming,trpc,typescript
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4.6
+Requires-Dist: msgspec>=0.19
+Requires-Dist: python-multipart>=0.0.18
+Requires-Dist: rich>=14.0
+Requires-Dist: starlette>=0.45
+Requires-Dist: typer>=0.15
+Requires-Dist: uvicorn[standard]>=0.32
+Requires-Dist: watchfiles>=1.0
+Provides-Extra: all
+Requires-Dist: opentelemetry-api>=1.27; extra == 'all'
+Requires-Dist: opentelemetry-sdk>=1.27; extra == 'all'
+Requires-Dist: pydantic>=2.10; extra == 'all'
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.27; extra == 'otel'
+Requires-Dist: opentelemetry-sdk>=1.27; extra == 'otel'
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2.10; extra == 'pydantic'
+Description-Content-Type: text/markdown
+
+# dyadpy (Python)
+
+> A type-safe RPC bridge between Python and TypeScript.
+
+```bash
+uv add dyadpy
+```
+
+This is the Python half of [Dyadpy](https://github.com/tamimbinhakim/dyadpy). It
+ships:
+
+- A thin ASGI framework (`dyadpy.App`) that uses your function signatures
+  as the contract — no separate Pydantic models declared above the
+  handler.
+- A type extractor that walks `inspect.signature` +
+  `typing.get_type_hints`, normalizes through `msgspec`'s native JSON
+  Schema export, and produces a canonical IR.
+- A codegen that turns the IR into a single `client.ts` for your
+  frontend.
+- A CLI (`dyadpy dev`, `dyadpy build`, `dyadpy codegen`, `dyadpy init`) that
+  runs the whole loop in one process.
+
+For the full story, the design rationale, and a side-by-side comparison
+vs. FastAPI + openapi-typescript / tRPC / Encore.ts / Connect-RPC, see
+the [repo README](https://github.com/tamimbinhakim/dyadpy).
+
+## 30-second example
+
+```python
+from dyadpy import App, stream, raises
+from dataclasses import dataclass
+import msgspec
+
+app = App()
+
+class CreatePost(msgspec.Struct):
+    title: str
+    body: str
+
+class Post(msgspec.Struct):
+    id: int
+    title: str
+    body: str
+
+@dataclass
+class PostNotFound(Exception):
+    post_id: int
+
+@app.post("/posts")
+async def create_post(data: CreatePost) -> Post: ...
+
+@app.get("/posts/{post_id}")
+@raises(PostNotFound)
+async def get_post(post_id: int) -> Post: ...
+
+class Tick(msgspec.Struct, tag="tick"):
+    seq: int
+
+@app.get("/ticks")
+async def ticks(count: int) -> stream[Tick]:
+    for i in range(count):
+        yield Tick(seq=i)
+```
+
+Run it:
+
+```bash
+dyadpy dev server.app:app
+```
+
+The watcher writes `frontend/src/lib/dyadpy/client.ts` automatically. Then
+in your frontend:
+
+```ts
+import { api } from "@/lib/dyadpy/client";
+
+const post = await api.createPost({ data: { title: "hi", body: "world" } });
+
+for await (const ev of api.ticks({ count: 10 })) {
+  /* typed */
+}
+```
+
+## Primitives in this package
+
+| Primitive                                                           | Purpose                                                     |
+| ------------------------------------------------------------------- | ----------------------------------------------------------- |
+| `App` + `@app.{get,post,put,patch,delete}`                          | Route decorators.                                           |
+| `Annotated[T, Body / Query / Path / Header / Cookie / File / Form]` | Parameter location markers.                                 |
+| `Annotated[list[T], Query()]`                                       | Repeated query params (`?tag=a&tag=b`).                     |
+| `Bytes`                                                             | Raw request / response bodies. Skips the JSON envelope.     |
+| `stream[T]`                                                         | Typed SSE — client gets `AsyncIterable<T>`.                 |
+| `@raises(E1, E2, …)`                                                | Typed error union → `Result<T, E1 \| E2>` on the TS side.   |
+| `Context.set_status / set_header / set_cookie / after`              | Shape the response without dropping to Starlette.           |
+| `Depends(provider)`                                                 | DI in the FastAPI shape.                                    |
+| `after(fn, …)`                                                      | Run a callback after the response is sent.                  |
+| `InMemoryBackend` + `TaskBackend` Protocol                          | Background jobs.                                            |
+| `dyadpy.otel.instrument(app)`                                       | One OpenTelemetry span per request (`dyadpy[otel]`).        |
+| `dyadpy openapi / swift / kotlin` (CLI)                             | Emit OpenAPI 3.1, Swift, or Kotlin clients off the same IR. |
+
+Full reference: <https://github.com/tamimbinhakim/dyadpy/blob/main/docs/reference.md>
+
+## Optional extras
+
+```bash
+uv add 'dyadpy[pydantic]'  # Pydantic plugin (model_validate + model_json_schema)
+uv add 'dyadpy[otel]'      # OpenTelemetry middleware
+uv add 'dyadpy[all]'       # everything
+```
+
+## Scope
+
+Dyadpy ships at the wire level: RPC, typed streaming, typed errors,
+cancellation, file uploads, dependency injection. It does **not** ship
+vertical integrations — no LLM types, no React hooks in core, no
+chat-bot primitives. Those layers compose on top of the fundamentals
+and live in their own packages.
+
+## License
+
+MIT

dyadpy-0.1.0a0/README.md

@@ -0,0 +1,121 @@
+# dyadpy (Python)
+
+> A type-safe RPC bridge between Python and TypeScript.
+
+```bash
+uv add dyadpy
+```
+
+This is the Python half of [Dyadpy](https://github.com/tamimbinhakim/dyadpy). It
+ships:
+
+- A thin ASGI framework (`dyadpy.App`) that uses your function signatures
+  as the contract — no separate Pydantic models declared above the
+  handler.
+- A type extractor that walks `inspect.signature` +
+  `typing.get_type_hints`, normalizes through `msgspec`'s native JSON
+  Schema export, and produces a canonical IR.
+- A codegen that turns the IR into a single `client.ts` for your
+  frontend.
+- A CLI (`dyadpy dev`, `dyadpy build`, `dyadpy codegen`, `dyadpy init`) that
+  runs the whole loop in one process.
+
+For the full story, the design rationale, and a side-by-side comparison
+vs. FastAPI + openapi-typescript / tRPC / Encore.ts / Connect-RPC, see
+the [repo README](https://github.com/tamimbinhakim/dyadpy).
+
+## 30-second example
+
+```python
+from dyadpy import App, stream, raises
+from dataclasses import dataclass
+import msgspec
+
+app = App()
+
+class CreatePost(msgspec.Struct):
+    title: str
+    body: str
+
+class Post(msgspec.Struct):
+    id: int
+    title: str
+    body: str
+
+@dataclass
+class PostNotFound(Exception):
+    post_id: int
+
+@app.post("/posts")
+async def create_post(data: CreatePost) -> Post: ...
+
+@app.get("/posts/{post_id}")
+@raises(PostNotFound)
+async def get_post(post_id: int) -> Post: ...
+
+class Tick(msgspec.Struct, tag="tick"):
+    seq: int
+
+@app.get("/ticks")
+async def ticks(count: int) -> stream[Tick]:
+    for i in range(count):
+        yield Tick(seq=i)
+```
+
+Run it:
+
+```bash
+dyadpy dev server.app:app
+```
+
+The watcher writes `frontend/src/lib/dyadpy/client.ts` automatically. Then
+in your frontend:
+
+```ts
+import { api } from "@/lib/dyadpy/client";
+
+const post = await api.createPost({ data: { title: "hi", body: "world" } });
+
+for await (const ev of api.ticks({ count: 10 })) {
+  /* typed */
+}
+```
+
+## Primitives in this package
+
+| Primitive                                                           | Purpose                                                     |
+| ------------------------------------------------------------------- | ----------------------------------------------------------- |
+| `App` + `@app.{get,post,put,patch,delete}`                          | Route decorators.                                           |
+| `Annotated[T, Body / Query / Path / Header / Cookie / File / Form]` | Parameter location markers.                                 |
+| `Annotated[list[T], Query()]`                                       | Repeated query params (`?tag=a&tag=b`).                     |
+| `Bytes`                                                             | Raw request / response bodies. Skips the JSON envelope.     |
+| `stream[T]`                                                         | Typed SSE — client gets `AsyncIterable<T>`.                 |
+| `@raises(E1, E2, …)`                                                | Typed error union → `Result<T, E1 \| E2>` on the TS side.   |
+| `Context.set_status / set_header / set_cookie / after`              | Shape the response without dropping to Starlette.           |
+| `Depends(provider)`                                                 | DI in the FastAPI shape.                                    |
+| `after(fn, …)`                                                      | Run a callback after the response is sent.                  |
+| `InMemoryBackend` + `TaskBackend` Protocol                          | Background jobs.                                            |
+| `dyadpy.otel.instrument(app)`                                       | One OpenTelemetry span per request (`dyadpy[otel]`).        |
+| `dyadpy openapi / swift / kotlin` (CLI)                             | Emit OpenAPI 3.1, Swift, or Kotlin clients off the same IR. |
+
+Full reference: <https://github.com/tamimbinhakim/dyadpy/blob/main/docs/reference.md>
+
+## Optional extras
+
+```bash
+uv add 'dyadpy[pydantic]'  # Pydantic plugin (model_validate + model_json_schema)
+uv add 'dyadpy[otel]'      # OpenTelemetry middleware
+uv add 'dyadpy[all]'       # everything
+```
+
+## Scope
+
+Dyadpy ships at the wire level: RPC, typed streaming, typed errors,
+cancellation, file uploads, dependency injection. It does **not** ship
+vertical integrations — no LLM types, no React hooks in core, no
+chat-bot primitives. Those layers compose on top of the fundamentals
+and live in their own packages.
+
+## License
+
+MIT

dyadpy-0.1.0a0/pyproject.toml

@@ -0,0 +1,171 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dyadpy"
+version = "0.1.0a0"
+description = "A type-safe RPC bridge between Python and TypeScript. The function signature is the contract."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+authors = [{ name = "Tamim Bin Hakim", email = "tamimbinhakim@users.noreply.github.com" }]
+keywords = [
+  "asgi",
+  "rpc",
+  "trpc",
+  "typescript",
+  "codegen",
+  "streaming",
+  "sse",
+  "msgspec",
+  "fastapi-alternative",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Framework :: AsyncIO",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Internet :: WWW/HTTP",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+
+dependencies = [
+  "msgspec>=0.19",
+  "starlette>=0.45",
+  "uvicorn[standard]>=0.32",
+  "watchfiles>=1.0",
+  "typer>=0.15",
+  "rich>=14.0",
+  "anyio>=4.6",
+  "python-multipart>=0.0.18",
+]
+
+[project.optional-dependencies]
+pydantic = ["pydantic>=2.10"]
+otel = ["opentelemetry-api>=1.27", "opentelemetry-sdk>=1.27"]
+all = ["dyadpy[pydantic,otel]"]
+
+[project.scripts]
+dyadpy = "dyadpy.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/tamimbinhakim/dyadpy"
+Documentation = "https://github.com/tamimbinhakim/dyadpy/tree/main/docs"
+Repository = "https://github.com/tamimbinhakim/dyadpy"
+Issues = "https://github.com/tamimbinhakim/dyadpy/issues"
+Changelog = "https://github.com/tamimbinhakim/dyadpy/blob/main/packages/dyadpy/CHANGELOG.md"
+
+[dependency-groups]
+dev = [
+  "pytest>=9.0",
+  "pytest-asyncio>=1.0",
+  "pytest-cov>=7.0",
+  "httpx>=0.28",
+  "ruff>=0.13",
+  "mypy>=1.18",
+  "types-setuptools",
+  "pydantic>=2.10",
+  "opentelemetry-api>=1.27",
+  "opentelemetry-sdk>=1.27",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dyadpy"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/src", "/tests", "/README.md", "/CHANGELOG.md"]
+
+# ---- ruff ----
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+  "E",
+  "F",
+  "W", # pycodestyle / pyflakes
+  "I", # isort
+  "B", # bugbear
+  "UP", # pyupgrade
+  "SIM", # simplify
+  "C4", # comprehensions
+  "PT", # pytest
+  "RUF", # ruff
+  "TID", # tidy imports
+  "PYI", # type stubs
+  "ANN", # annotations
+]
+ignore = [
+  "ANN401", # allow Any in select cases
+  "E501", # line length handled by formatter
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["ANN", "B017", "PT011"]
+
+# ---- pyright / Pylance ----
+# In tests, ``@app.get(...)`` consumes the decorated function via its side
+# effect (route registration). Pylance can't see that, so it flags every
+# handler as unused. Quiet that *only* for tests; production code keeps strict.
+[tool.pyright]
+include = ["src", "tests"]
+typeCheckingMode = "strict"
+
+[[tool.pyright.executionEnvironments]]
+root = "tests"
+reportUnusedFunction = false
+
+[tool.ruff.lint.flake8-bugbear]
+# ``Depends(...)`` is the FastAPI-shaped DI marker — used as a default arg by
+# design. Whitelisting it here keeps user code free of B008 noise.
+extend-immutable-calls = ["dyadpy.Depends", "dyadpy.context.Depends"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["dyadpy"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+docstring-code-format = true
+
+# ---- mypy ----
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_unreachable = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+disallow_any_generics = true
+no_implicit_reexport = true
+files = ["src/dyadpy"]
+
+[[tool.mypy.overrides]]
+module = "tests.*"
+disallow_untyped_defs = false
+
+# ---- pytest ----
+[tool.pytest.ini_options]
+minversion = "8.0"
+testpaths = ["tests"]
+asyncio_mode = "auto"
+addopts = ["-ra", "--strict-markers", "--strict-config"]
+filterwarnings = ["error"]
+
+# ---- coverage ----
+[tool.coverage.run]
+branch = true
+source = ["dyadpy"]
+omit = ["src/dyadpy/cli.py"]
+
+[tool.coverage.report]
+exclude_lines = ["pragma: no cover", "if TYPE_CHECKING:", "raise NotImplementedError", "\\.\\.\\."]

dyadpy-0.1.0a0/src/dyadpy/__init__.py

@@ -0,0 +1,68 @@
+"""Dyadpy — a type-safe RPC bridge between Python and TypeScript.
+
+The function signature is the contract. See
+https://github.com/tamimbinhakim/dyadpy for full docs.
+
+``dyadpy.tasks`` is loaded lazily via PEP 562 — it drags ``asyncio``'s
+unix-event-loop internals that only matter when you actually queue a
+background job. Bidi is cheap to import eagerly (only ``msgspec`` at
+runtime; ``starlette.websockets`` is ``TYPE_CHECKING``-only) so it stays
+on the default path.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from dyadpy.app import App
+from dyadpy.bidi import BidiChannel, bidi
+from dyadpy.context import Context, Depends, after
+from dyadpy.errors import raises
+from dyadpy.params import Form
+from dyadpy.streaming import SsePayload, stream
+
+if TYPE_CHECKING:  # pragma: no cover - re-export shape only
+    from dyadpy.tasks import (
+        InMemoryBackend,
+        TaskBackend,
+        TaskState,
+        mount_task_routes,
+    )
+
+# Raw-body sentinel: annotate a handler param or return with ``Bytes`` to
+# skip the JSON envelope entirely. Identical to the ``bytes`` builtin; the
+# alias is exported for documentation and explicit-intent reasons.
+Bytes = bytes
+
+_LAZY_TASKS = {"InMemoryBackend", "TaskBackend", "TaskState", "mount_task_routes"}
+
+
+def __getattr__(name: str) -> Any:
+    # ``importlib.import_module`` (not ``from dyadpy import ...``) so we don't
+    # recurse into this very ``__getattr__`` looking up the submodule.
+    if name in _LAZY_TASKS:
+        import importlib
+
+        return getattr(importlib.import_module("dyadpy.tasks"), name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "App",
+    "BidiChannel",
+    "Bytes",
+    "Context",
+    "Depends",
+    "Form",
+    "InMemoryBackend",
+    "SsePayload",
+    "TaskBackend",
+    "TaskState",
+    "after",
+    "bidi",
+    "mount_task_routes",
+    "raises",
+    "stream",
+]
+
+__version__ = "0.1.0a0"

dyadpy-0.1.0a0/src/dyadpy/_idents.py

@@ -0,0 +1,11 @@
+"""Identifier transforms shared between codegen and polyglot renderers."""
+
+from __future__ import annotations
+
+
+def to_camel(name: str) -> str:
+    """``user_id`` → ``userId``. PascalCase / camelCase / mixed pass through untouched."""
+    if "_" not in name:
+        return name
+    head, *rest = name.split("_")
+    return head + "".join(p[:1].upper() + p[1:] for p in rest if p)