uncompose-engine 0.1.0__py3-none-any.whl

uncompose_engine/__init__.py

@@ -0,0 +1,5 @@
+"""uncompose-engine: the Python side of the Engine Contract (ADR-0001).
+
+Spawned by the core, never imported by it. Request JSON on stdin, JSONL
+events on stdout, all human logging on stderr.
+"""

uncompose_engine/__main__.py

@@ -0,0 +1,117 @@
+"""Engine Contract entry point: `python -m uncompose_engine`.
+
+Reads one JSON request from stdin, runs the model via audio-separator, and
+emits JSONL events on stdout. Everything else (library logging, tqdm bars,
+stray prints) is forced onto stderr so the event stream stays parseable.
+"""
+
+import importlib.metadata
+import json
+import logging
+import os
+import sys
+import time
+
+import torch
+from audio_separator.separator import Separator
+
+# Models known to this engine: audio-separator filename plus the mapping
+# from audio-separator's stem names to Uncompose's preset-level stem names
+# (keys.wav, not piano.wav — the model is piano-trained, the name is stable).
+MODELS = {
+    "mel_band_roformer_kim": {
+        "filename": "vocals_mel_band_roformer.ckpt",
+        # audio-separator calls this model's non-vocal stem "Other".
+        "output_names": {
+            "Vocals": "vocals",
+            "Other": "instrumental",
+        },
+    },
+    "htdemucs_6s": {
+        "filename": "htdemucs_6s.yaml",
+        "output_names": {
+            "Vocals": "vocals",
+            "Drums": "drums",
+            "Bass": "bass",
+            "Guitar": "guitar",
+            "Piano": "keys",
+            "Other": "other",
+        },
+    },
+}
+
+
+def main() -> int:
+    # Keep a private handle to the real stdout for events, then point fd 1
+    # at stderr so nothing the ML stack prints can corrupt the JSONL stream.
+    events = os.fdopen(os.dup(1), "w", buffering=1)
+    os.dup2(2, 1)
+    sys.stdout = sys.stderr
+
+    def emit(event: dict) -> None:
+        events.write(json.dumps(event) + "\n")
+
+    try:
+        request = json.load(sys.stdin)
+        return run(request, emit)
+    except Exception as exc:  # terminal: report on the contract, exit nonzero
+        logging.exception("engine failed")
+        emit({"event": "error", "message": str(exc)})
+        return 1
+
+
+def run(request: dict, emit) -> int:
+    model = MODELS.get(request["model_id"])
+    if model is None:
+        raise ValueError(f"unknown model id: {request['model_id']}")
+
+    logging.basicConfig(stream=sys.stderr, level=logging.INFO)
+
+    emit({"event": "stage", "stage": "model_load", "message": request["model_id"]})
+    t0 = time.monotonic()
+    separator = Separator(
+        output_dir=request["output_dir"],
+        model_file_dir=request["model_dir"],
+        output_format="wav",
+    )
+    separator.load_model(model_filename=model["filename"])
+    model_load_secs = time.monotonic() - t0
+
+    emit({"event": "stage", "stage": "separate"})
+    t1 = time.monotonic()
+    separator.separate(request["audio_path"], custom_output_names=model["output_names"])
+    separate_secs = time.monotonic() - t1
+
+    # audio-separator can swallow decode failures and return with nothing
+    # written; missing stems are a failed job, not a quiet success. Each stem
+    # is staged as `<stem>.wav.partial`; the core promotes it to its final
+    # name when it sees the stem event, so a crash leaves partials behind.
+    missing = []
+    for stem_name in model["output_names"].values():
+        final = os.path.join(request["output_dir"], f"{stem_name}.wav")
+        if os.path.exists(final):
+            partial = final + ".partial"
+            os.replace(final, partial)
+            emit({"event": "stem", "name": stem_name, "path": partial})
+        else:
+            missing.append(stem_name)
+    if missing:
+        raise RuntimeError(f"separation produced no output for: {', '.join(missing)}")
+
+    emit(
+        {
+            "event": "done",
+            "model_id": request["model_id"],
+            "engine_version": importlib.metadata.version("uncompose-engine"),
+            "device": "cuda" if torch.cuda.is_available() else "cpu",
+            "timings": {
+                "model_load_secs": round(model_load_secs, 2),
+                "separate_secs": round(separate_secs, 2),
+            },
+        }
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

uncompose_engine-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: uncompose-engine
+Version: 0.1.0
+Summary: Separation engine shim: JSONL Engine Contract on one side, audio-separator on the other
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: audio-separator[gpu]>=0.44.5

uncompose_engine-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+uncompose_engine/__init__.py,sha256=gVCgmAo13iXQwFpSBQG0jwCHVsBHHaKqnuJ5I7XZ4So,196
+uncompose_engine/__main__.py,sha256=FSOyHK7i5OLz9C5aAieQ58ZmKYNMGzkzeeATit2MLJU,3940
+uncompose_engine-0.1.0.dist-info/METADATA,sha256=TfA0DW6iFpBgAC2R72A8Poe48bdalfpaM1FCZD6jPLQ,249
+uncompose_engine-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+uncompose_engine-0.1.0.dist-info/RECORD,,

uncompose_engine-0.1.0.dist-info/WHEEL

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