lingot 0.0.1__tar.gz

lingot-0.0.1/.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.10", "3.11", "3.12"]
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]"
+      - run: pytest -q
+      - run: ruff check src/

lingot-0.0.1/.github/workflows/release.yml

@@ -0,0 +1,36 @@
+name: Release
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: pytest -q
+      - run: ruff check src/
+      - name: Smoke import
+        run: python -c "import lingot; print(lingot.__version__)"
+
+  publish:
+    needs: quality
+    runs-on: ubuntu-latest
+    environment: release
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build twine
+      - run: python -m build
+      - run: twine check dist/*
+      - uses: pypa/gh-action-pypi-publish@release/v1

lingot-0.0.1/.gitignore

@@ -0,0 +1,18 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+
+# Node / TS
+node_modules/
+ts/dist/
+
+# OS / editor
+.DS_Store
+Thumbs.db

lingot-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,51 @@
+# 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/justfile

@@ -0,0 +1,25 @@
+# Lingot — umbrella orchestrator. Conducts the worker services (cadastre, chitin,
+# oneiros, solver) into a labeled StagedScene. See ../LINGOT.md for the thesis.
+
+# Editable-install Lingot + the sibling worker repos for local dev.
+dev-install:
+    pip install -e ".[dev]"
+    pip install -e ../cadastre || echo "skip cadastre (not pip-installable yet)"
+    pip install -e ../chitin   || echo "skip chitin"
+    pip install -e ../oneiros  || echo "skip oneiros"
+
+# Run the Python test suite.
+test:
+    pytest
+
+# Run the pipeline on a spec file.
+run spec:
+    lingot run {{spec}}
+
+# Build the JS orchestrator (@autarkis/lingot).
+ts-build:
+    cd ts && npm install && npm run build
+
+# Build the Python wheel.
+build:
+    python -m build

lingot-0.0.1/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lingot"
+version = "0.0.1"
+description = "Umbrella orchestrator for the Autarkis spatial stack — the mint for embodied-AI ground truth."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Boris Blosse", email = "borisblosse@gmail.com" }]
+keywords = ["robotics", "synthetic-data", "simulation", "spatial", "ground-truth", "embodied-ai"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+# Worker services Lingot conducts. Commented until published; `just dev-install`
+# editable-installs the sibling repos from ../ for local dev.
+dependencies = [
+    # "cadastre",
+    # "chitin",
+    # "oneiros",
+    # "lingot-solver",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "ruff>=0.1", "pyright>=1.1", "build"]
+
+[project.scripts]
+lingot = "lingot.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/Autarkis/lingot"
+Repository = "https://github.com/Autarkis/lingot"
+Issues = "https://github.com/Autarkis/lingot/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lingot"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.pyright]
+include = ["src"]
+typeCheckingMode = "standard"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

lingot-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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/tests/test_smoke.py

@@ -0,0 +1,14 @@
+import pytest
+
+from lingot import Pipeline, __version__
+
+
+def test_version():
+    assert __version__ == "0.0.1"
+
+
+def test_unwired_stage_raises_clear_error():
+    # Every stage delegates to a worker adapter; with none wired, the first stage
+    # must fail loudly and name what to wire.
+    with pytest.raises(NotImplementedError, match="registry"):
+        Pipeline().run({})

lingot-0.0.1/ts/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@autarkis/lingot",
+  "version": "0.0.1",
+  "description": "The mint for the reserve currency of embodied AI — JS-side orchestrator/client for the Autarkis spatial stack.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test"
+  },
+  "license": "UNLICENSED",
+  "private": true
+}

lingot-0.0.1/ts/src/index.ts

@@ -0,0 +1,33 @@
+/**
+ * @autarkis/lingot — JS-side orchestrator / client for the Autarkis spatial stack.
+ *
+ * The bare npm name `lingot` is taken by an unrelated package, so the JS package
+ * is scoped under the org: `@autarkis/lingot`. (PyPI keeps the bare `lingot`.)
+ *
+ * Lingot is thin: it conducts the worker services and surfaces the StagedScene —
+ * the JSON interchange Atrium and FiftyOne consume — to JS/TS consumers.
+ */
+
+export interface StagedScene {
+  [key: string]: unknown;
+}
+
+export interface PipelineResult {
+  stagedScene: StagedScene;
+  artifacts: Record<string, unknown>;
+}
+
+/**
+ * Conducts the worker services. Real transport — HTTP/IPC to the Python
+ * pipeline, or the solver wasm binding — lands behind this seam.
+ */
+export class Lingot {
+  async run(_spec: Record<string, unknown>): Promise<PipelineResult> {
+    throw new Error(
+      "Lingot JS orchestrator is not wired yet: connect run() to the Python " +
+        "pipeline (HTTP/IPC) or the solver wasm binding.",
+    );
+  }
+}
+
+export const VERSION = "0.0.1";

lingot-0.0.1/ts/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}