lingot 0.0.1__py3-none-any.whl

lingot/__init__.py

@@ -0,0 +1,14 @@
+"""Lingot — umbrella orchestrator for the Autarkis spatial stack.
+
+Lingot is thin. It depends on the worker services — cadastre (registry + solve),
+chitin (physics compile), oneiros (render) — and conducts them through the
+pipeline that turns a constraint spec into an exported, labeled StagedScene.
+
+It is the mint: spec in, certified unit of ground truth out. The workers are the
+machinery; Lingot owns the order and the hand-off. See ../LINGOT.md for the thesis.
+"""
+
+from lingot.pipeline import Pipeline, PipelineResult
+
+__version__ = "0.0.1"
+__all__ = ["Pipeline", "PipelineResult", "__version__"]

lingot/cli.py

@@ -0,0 +1,42 @@
+"""`lingot` command-line entrypoint."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from lingot import __version__
+from lingot.pipeline import Pipeline
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="lingot",
+        description="Mint a StagedScene from a constraint spec by conducting the worker services.",
+    )
+    parser.add_argument("--version", action="version", version=f"lingot {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    run = sub.add_parser("run", help="Run the full pipeline on a spec file.")
+    run.add_argument("spec", help="Path to a constraint spec (JSON).")
+    run.add_argument("-o", "--out", help="Write the StagedScene JSON here (default: stdout).")
+
+    args = parser.parse_args(argv)
+
+    if args.command == "run":
+        result = Pipeline().run_file(args.spec)
+        payload = json.dumps(result.staged_scene, indent=2)
+        if args.out:
+            Path(args.out).write_text(payload, encoding="utf-8")
+            print(f"wrote {args.out}", file=sys.stderr)
+        else:
+            print(payload)
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

lingot/pipeline.py

@@ -0,0 +1,49 @@
+"""The Lingot pipeline: constraint spec -> exported, labeled StagedScene.
+
+Stage order mirrors the stack architecture:
+
+    spec --> registry(build) --> solver(resolve) --> chitin(compile physics)
+         --> oneiros(render) --> export(StagedScene)
+
+Lingot owns the order and the data hand-off; each stage is delegated to a worker
+adapter (see workers.py). A stage with no wired worker raises a clear
+NotImplementedError naming what to wire — the skeleton runs end-to-end the moment
+the seams are filled.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from lingot.workers import Workers, load_default_workers
+
+
+@dataclass
+class PipelineResult:
+    staged_scene: dict[str, Any]
+    artifacts: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Pipeline:
+    """Conducts the worker services through the scene-minting pipeline."""
+
+    workers: Workers = field(default_factory=load_default_workers)
+
+    def run(self, spec: dict[str, Any]) -> PipelineResult:
+        w = self.workers
+
+        scene = w.require("registry").build_scene(spec)
+        scene = w.require("solver").resolve(scene)
+        scene = w.require("compiler").compile_physics(scene)
+        scene = w.require("renderer").render(scene)
+        staged = w.require("exporter").export(scene)
+
+        return PipelineResult(staged_scene=staged)
+
+    def run_file(self, spec_path: str | Path) -> PipelineResult:
+        spec = json.loads(Path(spec_path).read_text(encoding="utf-8"))
+        return self.run(spec)

lingot/workers.py

@@ -0,0 +1,78 @@
+"""Adapters to the worker services Lingot orchestrates.
+
+Each Protocol below is the seam between Lingot (the conductor) and one worker
+package (the instrument). Wiring a real tool means implementing one adapter and
+pointing it at that worker's real entrypoint — nothing else in the pipeline moves.
+
+Status: seams defined, real wiring TODO. We deliberately do NOT guess the workers'
+public APIs here (verify before calling); each adapter names the tool and the
+stage it owns so wiring is a localized, one-file job.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+
+# --- Worker seams (one per stage of the mint) ------------------------------
+
+
+class Registry(Protocol):
+    """cadastre — the spatial identity tree the scene is struck against."""
+
+    def build_scene(self, spec: dict[str, Any]) -> Any: ...
+
+
+class Solver(Protocol):
+    """force-directed constraint solver — resolves typed intent into geometry."""
+
+    def resolve(self, scene: Any) -> Any: ...
+
+
+class Compiler(Protocol):
+    """chitin — bakes physics, emitting .phys collider sidecars."""
+
+    def compile_physics(self, scene: Any) -> Any: ...
+
+
+class Renderer(Protocol):
+    """oneiros — casts the photoreal surface (Cosmos bridge) over the structure."""
+
+    def render(self, scene: Any) -> Any: ...
+
+
+class Exporter(Protocol):
+    """scene_to_dict / StagedScene — JSON interchange Atrium and FiftyOne consume."""
+
+    def export(self, scene: Any) -> dict[str, Any]: ...
+
+
+@dataclass
+class Workers:
+    """Container of wired worker adapters. Unwired seams raise a clear error."""
+
+    registry: Registry | None = None
+    solver: Solver | None = None
+    compiler: Compiler | None = None
+    renderer: Renderer | None = None
+    exporter: Exporter | None = None
+
+    def require(self, name: str) -> Any:
+        worker = getattr(self, name)
+        if worker is None:
+            raise NotImplementedError(
+                f"Lingot worker '{name}' is not wired yet. Implement the {name!r} "
+                f"adapter against the real package and pass it into "
+                f"Pipeline(workers=Workers({name}=...))."
+            )
+        return worker
+
+
+def load_default_workers() -> Workers:
+    """Best-effort discovery of installed worker packages.
+
+    Returns an empty Workers() for now — real adapters land here as each tool's
+    public API is verified (`just dev-install` makes the sibling repos importable).
+    """
+    return Workers()

lingot-0.0.1.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: lingot
+Version: 0.0.1
+Summary: Umbrella orchestrator for the Autarkis spatial stack — the mint for embodied-AI ground truth.
+Project-URL: Homepage, https://github.com/Autarkis/lingot
+Project-URL: Repository, https://github.com/Autarkis/lingot
+Project-URL: Issues, https://github.com/Autarkis/lingot/issues
+Author-email: Boris Blosse <borisblosse@gmail.com>
+Keywords: embodied-ai,ground-truth,robotics,simulation,spatial,synthetic-data
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pyright>=1.1; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Lingot
+
+**The mint for the reserve currency of embodied AI.** Lingot is the umbrella
+orchestrator of the Autarkis spatial stack — the thin layer that depends on the
+worker services and conducts them through one pipeline:
+
+```
+spec -> cadastre (registry + solve) -> chitin (physics .phys) -> oneiros (render) -> StagedScene
+```
+
+Lingot is intentionally thin. It owns the *order* and the *data hand-off*; the
+work lives in the workers, each an independently published package.
+
+## Install
+
+```bash
+pip install lingot            # Python orchestrator + CLI   (PyPI: lingot)
+npm install @autarkis/lingot  # JS orchestrator / client    (npm bare `lingot` is taken -> scoped)
+```
+
+> The Rust force-directed solver is **not** vendored here — it ships as its own
+> worker package and is pulled in as a dependency. Lingot orchestrates; it does
+> not implement.
+
+## Local development
+
+The worker repos are siblings (`../cadastre`, `../chitin`, `../oneiros`). Wire
+them in editable mode, then run the pipeline on a spec:
+
+```bash
+just dev-install
+just run path/to/spec.json
+```
+
+Every pipeline stage delegates to a worker adapter in `src/lingot/workers.py`.
+Stages with no wired worker raise a clear error naming what to connect — the
+skeleton runs end-to-end the moment the seams are filled.
+
+## Layout
+
+```
+lingot/
+|- src/lingot/         # Python orchestrator
+|  |- pipeline.py      #   stage order + data hand-off
+|  |- workers.py       #   one adapter seam per worker service
+|  \- cli.py           #   `lingot run spec.json`
+|- ts/                 # @autarkis/lingot — JS orchestrator / client
+\- justfile            # dev / test / build across py + ts
+```
+
+See [`../LINGOT.md`](../LINGOT.md) for the full thesis.

lingot-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+lingot/__init__.py,sha256=YgYcS0UeYA0oIXEfcmdvI4IOCn0A1uaiqEFKhhdfMOw,609
+lingot/cli.py,sha256=TFpnfCZ6xR8SsXfzlC409RgKTsLWoiUzTEH68_85rLo,1270
+lingot/pipeline.py,sha256=Z-ucovz9JrEE2jMjwKsG5EFljbNi-edBKV3v1L_jnro,1586
+lingot/workers.py,sha256=_wDO1BSTTN5MACYFtIOJrnFwwnO_PPFZT3n29bR2uDs,2494
+lingot-0.0.1.dist-info/METADATA,sha256=X8xPXX68GoFXCX9C6_weJDoCnJy9uVKPBygH6C_-Avo,2896
+lingot-0.0.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+lingot-0.0.1.dist-info/entry_points.txt,sha256=pyFF4AyR825yM-Q1eya3fgVYdMpNUpnk0VmkrVey92U,43
+lingot-0.0.1.dist-info/RECORD,,

lingot-0.0.1.dist-info/WHEEL

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

lingot-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lingot = lingot.cli:main