pipe-broker 0.1.0__tar.gz

pipe_broker-0.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: pipe-broker
+Version: 0.1.0
+Summary: Atomic, data-in/data-out operations for multilingual translation and domain-expertise knowledge export.
+License: MIT
+Keywords: pipe,operations,translation,nlp,fastapi,atomic,streaming
+Author: amaagracodes
+Requires-Python: >=3.11
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Dist: babel
+Requires-Dist: dspy (>=3.3,<4)
+Requires-Dist: fastapi
+Requires-Dist: httpx
+Requires-Dist: jinja2
+Requires-Dist: python-multipart
+Requires-Dist: uvicorn
+Project-URL: Documentation, https://github.com/amaagracodes/pipe
+Project-URL: Homepage, https://github.com/amaagracodes/pipe
+Project-URL: Issues, https://github.com/amaagracodes/pipe/issues
+Project-URL: Repository, https://github.com/amaagracodes/pipe
+Description-Content-Type: text/markdown
+
+# Pipe
+
+Atomic, data-in/data-out operations for multilingual translation and domain-expertise knowledge export.
+
+The core library lives in `src/pipe` — installable as `pipe-broker`, imported as `pipe`. A thin, stateless API adapter in `src/api` runs as a Cloudflare Python Worker.
+
+Build uses `poetry-core`; dependencies are managed with `uv`.
+
+## Usage
+
+```python
+import pipe
+
+pipe.echo("hi")
+```
+

pipe_broker-0.1.0/README.md

@@ -0,0 +1,15 @@
+# Pipe
+
+Atomic, data-in/data-out operations for multilingual translation and domain-expertise knowledge export.
+
+The core library lives in `src/pipe` — installable as `pipe-broker`, imported as `pipe`. A thin, stateless API adapter in `src/api` runs as a Cloudflare Python Worker.
+
+Build uses `poetry-core`; dependencies are managed with `uv`.
+
+## Usage
+
+```python
+import pipe
+
+pipe.echo("hi")
+```

pipe_broker-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[project]
+name = "pipe-broker"
+version = "0.1.0"
+description = "Atomic, data-in/data-out operations for multilingual translation and domain-expertise knowledge export."
+authors = [{ name = "amaagracodes" }]
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+keywords = ["pipe", "operations", "translation", "nlp", "fastapi", "atomic", "streaming"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing :: Linguistic",
+]
+# All runtime deps are installed together — one install path, no optional
+# extras to forget. The service (Cloud Run, real CPython) always needs the
+# serving layer (FastAPI/Jinja2/uvicorn) and the LLM backend (DSPy, which
+# brings its own LiteLLM client that speaks OpenRouter via openrouter/<model>).
+dependencies = [
+    "fastapi",
+    "jinja2",
+    "uvicorn",
+    "dspy>=3.3,<4",
+    "httpx",
+    "python-multipart",
+    "babel",
+]
+
+[project.urls]
+Homepage = "https://github.com/amaagracodes/pipe"
+Repository = "https://github.com/amaagracodes/pipe"
+Documentation = "https://github.com/amaagracodes/pipe"
+Issues = "https://github.com/amaagracodes/pipe/issues"
+
+# Dev-only tooling (uv reads this): tests + a local ASGI runner.
+# The website is built with MkDocs Material (the same static-site generator
+# DSPy's docs use). It is a docs/build-time dependency only — the runtime
+# service just serves the already-built static output from public/.
+[dependency-groups]
+dev = ["pytest>=8", "uvicorn>=0.30"]
+docs = ["mkdocs-material>=9.5"]
+
+[build-system]
+requires = ["poetry-core>=2.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+packages = [{ include = "pipe", from = "src" }]
+
+
+[tool.pytest.ini_options]
+# Do not write .pytest_cache or __pycache__ during test runs.
+addopts = "-p no:cacheprovider"

pipe_broker-0.1.0/src/pipe/__init__.py

@@ -0,0 +1,16 @@
+"""pipe — atomic, data-in/data-out operations for multilingual translation
+and domain-expertise knowledge export.
+
+One top-level package with two parts:
+  * pipe.lib — the pure, dependency-free core ops (imported here for a flat
+    public API: ``import pipe; pipe.echo("hi")``).
+  * pipe.api — the optional serving adapter (FastAPI / Cloudflare Worker).
+    NOT imported here, so the core stays dependency-free; import it explicitly
+    (``from pipe.api.app import create_app``) with the ``[api]`` extra installed.
+"""
+
+from pipe.lib import Chain, Echo, EchoStream, Pipe, echo, echo_stream
+
+__all__ = ["Pipe", "Chain", "Echo", "EchoStream", "echo", "echo_stream"]
+
+__version__ = "0.1.0"

pipe_broker-0.1.0/src/pipe/api/__init__.py

@@ -0,0 +1,10 @@
+"""pipe.api — a thin, stateless serving layer over the pipe.lib core ops.
+
+An *adapter*: it wires the atomic operations in ``pipe.lib`` to an HTTP surface
+(FastAPI) suitable for running as a Cloudflare Python Worker. It owns no
+business logic. Requires the ``[api]`` extra (fastapi, jinja2).
+"""
+
+from pipe.api.app import create_app
+
+__all__ = ["create_app"]

pipe_broker-0.1.0/src/pipe/api/app.py

@@ -0,0 +1,55 @@
+"""FastAPI application factory.
+
+Builds the app and mounts routes. Two frontend paths coexist by design:
+
+  * Static assets (``public/``) — the landing page and any purely-static files.
+    On Cloudflare these are served via the Workers ASSETS binding; locally via
+    Starlette's StaticFiles. Best for content with no per-request data.
+
+  * Jinja2 templates (``pipe/api/templates/``) — for API-driven, server-rendered
+    pages that DO need per-request/dynamic data. Kept for API-based sites.
+"""
+
+import os
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.templating import Jinja2Templates
+
+import pipe
+
+_BASE_DIR = Path(__file__).resolve().parent
+# The static frontend directory. Priced from an env var first (set in the
+# container image to /app/public), falling back to the repo layout for local
+# dev (src/pipe/api/app.py -> repo root is 4 levels up). When the package is
+# pip-installed the repo-relative guess won't exist, which is why the container
+# sets PIPE_PUBLIC_DIR explicitly.
+PUBLIC_DIR = Path(
+    os.environ.get("PIPE_PUBLIC_DIR", str(Path(__file__).resolve().parents[3] / "public"))
+)
+# Server-side templates for dynamic, API-driven pages.
+TEMPLATES = Jinja2Templates(directory=str(_BASE_DIR / "templates"))
+
+
+def create_app() -> FastAPI:
+    # When served behind a reverse proxy under a path prefix (e.g.
+    # /proxy/8787), set PIPE_ROOT_PATH to that prefix so FastAPI generates the
+    # correct URLs for /docs, /openapi.json, etc. Empty (default) = served at
+    # the domain root, as on Cloudflare Workers.
+    root_path = os.environ.get("PIPE_ROOT_PATH", "")
+
+    app = FastAPI(
+        title="pipe-broker",
+        version=pipe.__version__,
+        description=(
+            "Atomic, data-in/data-out operations for multilingual translation "
+            "and domain-expertise knowledge export."
+        ),
+        root_path=root_path,
+    )
+
+    # Routes are registered separately to keep concerns split.
+    from pipe.api.routes import register_routes
+
+    register_routes(app)
+    return app

pipe_broker-0.1.0/src/pipe/api/dev.py

@@ -0,0 +1,28 @@
+"""Local development server.
+
+Runs the exact same FastAPI app as the Cloudflare Worker, but via uvicorn so
+it can be tested locally without the Workers/Pyodide runtime.
+
+    uv run --extra api --with uvicorn python -m pipe.api.dev
+
+Binds 0.0.0.0 by default so it is reachable on localhost, LAN, and tailnet.
+Override with PIPE_HOST / PIPE_PORT.
+"""
+
+import os
+
+import uvicorn
+
+from pipe.api.app import create_app
+
+app = create_app()
+
+
+def main() -> None:
+    host = os.environ.get("PIPE_HOST", "0.0.0.0")
+    port = int(os.environ.get("PIPE_PORT", "8787"))
+    uvicorn.run(app, host=host, port=port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

pipe_broker-0.1.0/src/pipe/api/routes.py

@@ -0,0 +1,169 @@
+"""HTTP route handlers.
+
+Each handler is thin and async: parse input, call a ``pipe.lib`` atomic op,
+return output. Three response styles coexist:
+
+  * JSON ops        — /echo (buffered)
+  * streaming ops   — /echo/stream (incremental data stream)
+  * server-rendered — /status (Jinja2 template, for API-driven dynamic pages)
+
+The static frontend (public/) is mounted last at "/" so API routes and /docs
+take priority; index.html is served at "/".
+"""
+
+from fastapi import FastAPI, Request, UploadFile
+from fastapi.responses import HTMLResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+
+import pipe
+from pipe.api.app import PUBLIC_DIR, TEMPLATES
+
+
+def register_routes(app: FastAPI) -> None:
+    @app.get("/echo", tags=["ops"])
+    async def echo(data: str = "") -> dict:
+        """Echo atomic op: returns the input unchanged (data in, data out)."""
+        return {"data": pipe.echo(data)}
+
+    @app.get("/echo/stream", tags=["ops"])
+    async def echo_stream(data: str = "", chunk_size: int = 16) -> StreamingResponse:
+        """Streaming echo: sends the input back incrementally as a data stream."""
+        return StreamingResponse(
+            pipe.echo_stream(data, chunk_size=chunk_size),
+            media_type="text/plain; charset=utf-8",
+        )
+
+    # --- LLM (OpenRouter) -------------------------------------------------
+
+    @app.post("/llm", tags=["llm"])
+    async def llm(prompt: str, model: str = "openai/gpt-4o-mini", max_tokens: int = 256) -> dict:
+        """Test route: send a prompt to OpenRouter and return the completion.
+
+        Reads the key from $OPENROUTER_API_KEY (injected in the deployment).
+        Returns a 4xx-shaped JSON error rather than a 500 when the LLM stack or
+        key is unavailable, so it's safe to probe.
+        """
+        from fastapi import HTTPException
+
+        from pipe.lib.providers import OpenRouterProvider
+
+        provider = OpenRouterProvider(model=model, max_tokens=max_tokens)
+        try:
+            text = await provider.acall(prompt)
+        except ModuleNotFoundError as exc:
+            raise HTTPException(status_code=501, detail=str(exc)) from exc
+        except RuntimeError as exc:  # missing key
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+        except Exception as exc:  # upstream/LLM error — don't leak internals
+            raise HTTPException(status_code=502, detail=f"LLM call failed: {type(exc).__name__}") from exc
+        return {"model": provider.model, "prompt": prompt, "completion": text}
+
+    # --- legal atomic ops -------------------------------------------------
+
+    @app.get("/legal/ops", tags=["legal"])
+    async def legal_ops() -> dict:
+        """List the available atomic legal operations and rule categories."""
+        from pipe.lib.experts import legal
+
+        return {
+            "operations": [
+                "detect_pii", "spot_clauses", "identify_statutes",
+                "extract_citations", "screen_privilege",
+            ],
+            "categories": sorted(legal.categories()),
+            "rule_count": len(legal.RULES),
+        }
+
+    @app.post("/legal/detect", tags=["legal"])
+    async def legal_detect(text: str, jurisdiction: str = "us", op: str = "detect_pii") -> dict:
+        """Run one atomic legal op over text for a given jurisdiction.
+
+        ``op`` is one of the names from ``GET /legal/ops``; ``jurisdiction`` is a
+        hierarchical code like ``us``, ``us/ny``, ``in/mh`` (optionally with
+        facets appended later). Returns the detections found.
+        """
+        from fastapi import HTTPException
+
+        from pipe.lib.experts.legal import (
+            DetectPII, ExtractCitations, IdentifyStatutes, ScreenPrivilege, SpotClauses,
+        )
+
+        ops = {
+            "detect_pii": DetectPII,
+            "spot_clauses": SpotClauses,
+            "identify_statutes": IdentifyStatutes,
+            "extract_citations": ExtractCitations,
+            "screen_privilege": ScreenPrivilege,
+        }
+        op_cls = ops.get(op)
+        if op_cls is None:
+            raise HTTPException(status_code=400, detail=f"unknown op {op!r}; choose from {sorted(ops)}")
+        result = op_cls(jurisdiction)(text)
+        return {
+            "op": op,
+            "jurisdiction": jurisdiction,
+            "detections": [
+                {
+                    "kind": d.kind,
+                    "label": d.label,
+                    "severity": d.severity.name,
+                    "span": [d.span.start, d.span.end] if d.span else None,
+                }
+                for d in result.detections
+            ],
+            "meta": result.document.meta,
+        }
+
+    # --- speech-to-text (OpenRouter) --------------------------------------
+
+    @app.post("/stt", tags=["llm"])
+    async def stt(
+        file: UploadFile,
+        model: str = "openai/whisper-large-v3",
+        language: str | None = None,
+    ) -> dict:
+        """Transcribe an uploaded audio file to text (audio bytes in, text out).
+
+        Accepts a multipart file upload; the audio format is inferred from the
+        filename extension (falls back to ``wav``). Reads the key from
+        $OPENROUTER_API_KEY. Errors map like /llm (503 missing key, 502 upstream).
+        """
+        from fastapi import HTTPException
+
+        from pipe.lib.providers import STT
+
+        audio = await file.read()
+        # Derive the container format from the upload's extension.
+        fmt = "wav"
+        if file.filename and "." in file.filename:
+            fmt = file.filename.rsplit(".", 1)[-1].lower()
+
+        provider = STT(model=model, language=language)
+        try:
+            text = await provider.acall(audio, format=fmt)
+        except RuntimeError as exc:  # missing key
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+        except Exception as exc:  # upstream/transcription error — don't leak internals
+            raise HTTPException(status_code=502, detail=f"STT call failed: {type(exc).__name__}") from exc
+        return {"model": provider.model, "format": fmt, "text": text}
+
+    @app.get("/status", response_class=HTMLResponse, include_in_schema=False)
+    async def status(request: Request, data: str = "pong"):
+        """Server-rendered (Jinja2) page — kept for dynamic, API-driven sites."""
+        return TEMPLATES.TemplateResponse(
+            request,
+            "status.html",
+            {
+                "version": pipe.__version__,
+                "echoed": pipe.echo(data),
+                "ops": ["echo", "echo_stream"],
+            },
+        )
+
+    # Static frontend, mounted LAST so the API routes above (and /docs,
+    # /openapi.json) match first. html=True serves index.html at "/". The
+    # public/ directory ships in the container image (and exists in local dev).
+    # The is_dir guard just keeps the app importable in environments where the
+    # directory isn't present (e.g. running the ops library without the site).
+    if PUBLIC_DIR.is_dir():
+        app.mount("/", StaticFiles(directory=str(PUBLIC_DIR), html=True), name="site")

pipe_broker-0.1.0/src/pipe/api/server.py

@@ -0,0 +1,28 @@
+"""Production ASGI server entrypoint (container / Cloud Run).
+
+Cloud Run injects the port to listen on via the ``PORT`` env var (default 8080)
+and expects the process to bind 0.0.0.0. This module exposes the ASGI ``app``
+for ``uvicorn pipe.api.server:app`` and a ``main()`` for direct execution.
+"""
+
+import os
+
+import uvicorn
+
+from pipe.api.app import create_app
+
+app = create_app()
+
+
+def main() -> None:
+    port = int(os.environ.get("PORT", "8080"))
+    uvicorn.run(
+        "pipe.api.server:app",
+        host="0.0.0.0",
+        port=port,
+        log_level=os.environ.get("LOG_LEVEL", "info"),
+    )
+
+
+if __name__ == "__main__":
+    main()

pipe_broker-0.1.0/src/pipe/api/templates/status.html

@@ -0,0 +1,29 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>pipe-broker · status</title>
+  <link rel="stylesheet" href="style.css" />
+</head>
+<body>
+  <div class="glow" aria-hidden="true"></div>
+  <main>
+    <section class="hero">
+      <span class="pill">server-rendered</span>
+      <h1 class="grad">pipe-broker status</h1>
+      <p class="sub">
+        This page is rendered server-side from a Jinja2 template — the path we
+        keep for dynamic, API-driven pages.
+      </p>
+      <div class="panel" style="max-width:32rem;margin:0 auto;text-align:left">
+        <p><strong>Version:</strong> {{ version }}</p>
+        <p><strong>Echoed value:</strong> {{ echoed }}</p>
+        <p><strong>Ops available:</strong>
+          {% for op in ops %}<code>{{ op }}</code>{% if not loop.last %}, {% endif %}{% endfor %}
+        </p>
+      </div>
+    </section>
+  </main>
+</body>
+</html>

pipe_broker-0.1.0/src/pipe/lib/__init__.py

@@ -0,0 +1,44 @@
+"""pipe.lib — the pure, stateless core: atomic data-in/data-out operations.
+
+Zero runtime dependencies. No I/O, no framework, no global state. Safe to run
+anywhere Python does, including Cloudflare's Pyodide runtime.
+
+The interface primitives live in the modular :mod:`pipe.lib.core` subpackage
+and are re-exported here for a flat import surface. Two ways to use an op:
+
+  * the interface — subclass :class:`Pipe`, implement ``forward``/``stream``,
+    invoke by calling the instance, and chain with ``>>``. This is the
+    DSPy-style module pattern: a small, composable, uniformly-called atomic
+    layer.
+  * the flat helpers — ``echo`` / ``echo_stream`` remain as functions for
+    callers that just want data in, data out.
+
+Higher layers build on this: the generic modules :mod:`~pipe.lib.shared`,
+:mod:`~pipe.lib.providers`, :mod:`~pipe.lib.experts`, :mod:`~pipe.lib.detectors`,
+and the domain operations in :mod:`~pipe.lib.experts.legal`.
+"""
+
+from pipe.lib.core import (
+    BasePipe,
+    Chain,
+    Echo,
+    EchoStream,
+    Pipe,
+    PipeMeta,
+    echo,
+    echo_stream,
+)
+
+__all__ = [
+    # interface layer
+    "BasePipe",
+    "Pipe",
+    "PipeMeta",
+    "Chain",
+    # concrete ops
+    "Echo",
+    "EchoStream",
+    # flat function API
+    "echo",
+    "echo_stream",
+]

pipe_broker-0.1.0/src/pipe/lib/core/__init__.py

@@ -0,0 +1,30 @@
+"""pipe.lib.core — the interface primitives for atomic ops.
+
+A modular, DSPy-shaped module system split across small files:
+
+  * :mod:`~pipe.lib.core.base`  — ``BasePipe`` (structural) + ``PipeMeta``.
+  * :mod:`~pipe.lib.core.pipe`  — ``Pipe``, the atomic callable interface.
+  * :mod:`~pipe.lib.core.chain` — ``Chain``, the composite that sequences ops.
+  * :mod:`~pipe.lib.core.ops`   — concrete ops (``Echo``, ``EchoStream``) and
+    the flat ``echo`` / ``echo_stream`` function API.
+"""
+
+from pipe.lib.core.base import BasePipe, PipeMeta
+from pipe.lib.core.chain import Chain
+from pipe.lib.core.context import current_context, require_context, use_context
+from pipe.lib.core.ops import Echo, EchoStream, echo, echo_stream
+from pipe.lib.core.pipe import Pipe
+
+__all__ = [
+    "BasePipe",
+    "PipeMeta",
+    "Pipe",
+    "Chain",
+    "Echo",
+    "EchoStream",
+    "echo",
+    "echo_stream",
+    "current_context",
+    "use_context",
+    "require_context",
+]

pipe_broker-0.1.0/src/pipe/lib/core/base.py

@@ -0,0 +1,111 @@
+"""pipe.lib.core.base — the structural layer + metaclass.
+
+DSPy splits its abstraction in two:
+
+  * ``BaseModule`` — the *structural* layer. It knows nothing about calling;
+    it only walks an instance's attributes to discover nested sub-modules,
+    enabling introspection, composition and copying.
+  * ``Module`` — the *behavioural* layer (see :mod:`pipe.lib.core.pipe`).
+
+``BasePipe`` here is that structural layer for pipe, and ``PipeMeta`` is the
+metaclass that guarantees base attributes exist on every ``Pipe`` — analogous
+to DSPy's ``ProgramMeta``.
+
+No third-party imports: safe under Cloudflare's Pyodide runtime.
+"""
+
+from __future__ import annotations
+
+import copy
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from pipe.lib.core.pipe import Pipe
+
+__all__ = ["BasePipe", "PipeMeta"]
+
+
+class BasePipe:
+    """Structural layer: attribute-walking, discovery, and copying.
+
+    Analogous to ``dspy.primitives.BaseModule``. Holds no calling logic — it
+    only understands how ``Pipe``s nest inside one another so that a composite
+    ``Pipe`` can be introspected and copied as a unit.
+    """
+
+    def named_pipes(self) -> list[tuple[str, "Pipe"]]:
+        """Return ``(name, pipe)`` for every ``Pipe`` reachable from ``self``.
+
+        Walks ``__dict__`` one level deep, descending into nested ``Pipe``s and
+        into lists/tuples/dicts of ``Pipe``s. Names use dotted / indexed paths
+        (``"encoder"``, ``"stages[0]"``, ``"routes['en']"``) so each sub-pipe
+        has a stable address. Mirrors ``BaseModule.named_parameters``.
+        """
+        from pipe.lib.core.pipe import Pipe
+
+        visited: set[int] = set()
+        found: list[tuple[str, "Pipe"]] = []
+
+        def add(name: str, value: Any) -> None:
+            if isinstance(value, Pipe):
+                if id(value) in visited:
+                    return
+                visited.add(id(value))
+                found.append((name, value))
+                # Descend so composites of composites are fully discovered.
+                for sub_name, sub in value.named_pipes():
+                    child = f"{name}.{sub_name}"
+                    if id(sub) not in visited:
+                        visited.add(id(sub))
+                        found.append((child, sub))
+            elif isinstance(value, (list, tuple)):
+                for i, item in enumerate(value):
+                    add(f"{name}[{i}]", item)
+            elif isinstance(value, dict):
+                for key, item in value.items():
+                    add(f"{name}[{key!r}]", item)
+
+        for name, value in self.__dict__.items():
+            add(name, value)
+        return found
+
+    def pipes(self) -> list["Pipe"]:
+        """All nested ``Pipe`` instances (names dropped)."""
+        return [p for _, p in self.named_pipes()]
+
+    def deepcopy(self) -> "BasePipe":
+        """Deep copy, falling back to a shallow attribute copy if needed.
+
+        Mirrors ``BaseModule.deepcopy``: a plain ``copy.deepcopy`` when the
+        instance allows it, otherwise a best-effort attribute-by-attribute copy.
+        """
+        try:
+            return copy.deepcopy(self)
+        except Exception:
+            new = self.__class__.__new__(self.__class__)
+            for attr, value in self.__dict__.items():
+                try:
+                    setattr(new, attr, copy.deepcopy(value))
+                except Exception:
+                    setattr(new, attr, copy.copy(value))
+            return new
+
+
+class PipeMeta(type):
+    """Metaclass guaranteeing base attributes exist on every ``Pipe``.
+
+    Analogous to DSPy's ``ProgramMeta``: it runs ``Pipe._base_init`` before the
+    subclass ``__init__`` so a subclass that forgets ``super().__init__()``
+    still has the attributes the framework relies on (here: ``name``).
+    """
+
+    def __call__(cls, *args: Any, **kwargs: Any) -> Any:
+        from pipe.lib.core.pipe import Pipe
+
+        obj = cls.__new__(cls, *args, **kwargs)
+        if isinstance(obj, cls):
+            Pipe._base_init(obj)
+            cls.__init__(obj, *args, **kwargs)
+            if not hasattr(obj, "name"):
+                obj.name = cls.__name__
+        return obj