demusic 0.1.0__py3-none-any.whl

demusic/__init__.py

@@ -0,0 +1,8 @@
+"""demusic - remove the background music that AI video models (Seedance, Kling, Veo, Hailuo,
+Wan, ...) bake into generated clips, while keeping dialogue, sound effects and ambience.
+
+Built and used in production by Dawnwood, an AI drama studio (https://dawnwood.ai).
+"""
+from .provenance import PROVENANCE, __version__, credit
+
+__all__ = ["PROVENANCE", "__version__", "credit"]

demusic/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

demusic/cli.py

@@ -0,0 +1,114 @@
+"""``demusic`` command line: check | strip | mcp.
+
+Exit codes (stable):
+  0  success (``check``: no music found in any file)
+  1  ``check`` found music in at least one file
+  2  usage error
+  3  runtime failure (ffmpeg missing, unreadable input, separation failed)
+
+With ``--json`` the only thing on stdout is one JSON object (progress goes to stderr).
+"""
+import argparse
+import json
+import os
+import sys
+
+from . import core, detect, ff
+from .provenance import PROVENANCE
+
+EXIT_OK, EXIT_MUSIC, EXIT_USAGE, EXIT_FAIL = 0, 1, 2, 3
+
+
+def _common(p):
+    p.add_argument("files", nargs="+", help="video or audio files")
+    p.add_argument("--separator", default="demucs",
+                   help="demucs (local, default) | fal (FAL_KEY) | a folder of stems for ONE file")
+    p.add_argument("--threshold", type=float, default=detect.MUSIC_P,
+                   help=f"classifier music probability (default {detect.MUSIC_P}; lower finds "
+                        "quieter beds and risks more false positives)")
+    p.add_argument("--loud-floor", type=float, default=core.LOUD_FLOOR_DBFS,
+                   help=f"melodic-stem loudness gate in dBFS (default {core.LOUD_FLOOR_DBFS})")
+    p.add_argument("--json", action="store_true", help="one JSON object on stdout")
+
+
+def _line(r):
+    if r.get("error"):
+        return f"{r['input']}: error: {r['error']}"
+    spans = ", ".join(f"{a:g}-{b:g}s" for a, b in r["spans"]) or "-"
+    s = f"{r['input']}: {'MUSIC' if r['music'] else 'clean'}  spans {spans}"
+    if r.get("melodic_dbfs") is not None:
+        s += f"  melodic {r['melodic_dbfs']} dBFS"
+    if r.get("strength") is not None:
+        s += f"  p={r['strength']}"
+    if r.get("output"):
+        s += f"\n  -> {r['action']}: {r['output']}"
+    if r.get("note"):
+        s += f"\n  note: {r['note']}"
+    return s
+
+
+def _run(a, strip: bool) -> int:
+    if os.path.isdir(a.separator) and len(a.files) > 1:
+        print("a folder of stems belongs to one file; pass a single file", file=sys.stderr)
+        return EXIT_USAGE
+    if strip and a.output and len(a.files) > 1:
+        print("-o is for a single file; use --out-dir for several", file=sys.stderr)
+        return EXIT_USAGE
+    results, failed = [], False
+    for f in a.files:
+        out, copy = None, False
+        if strip:
+            if a.output:
+                out, copy = a.output, True
+            elif a.out_dir:
+                out, copy = os.path.join(a.out_dir, os.path.basename(f)), True
+        if not a.json:
+            ff.log(f"demusic: {f}")
+        try:
+            r = core.process(f, out, strip=strip, separator=a.separator,
+                             mode=getattr(a, "mode", "spans"), threshold=a.threshold,
+                             loud_floor=a.loud_floor, copy_unchanged=copy)
+        except Exception as e:  # noqa: BLE001 - report per file, keep going through a batch
+            r, failed = {"ok": False, "input": os.path.abspath(f), "error": str(e)[:500]}, True
+        results.append(r)
+        if not a.json:
+            print(_line(r), flush=True)
+    found = sum(1 for r in results if r.get("music"))
+    if a.json:
+        print(json.dumps({"ok": not failed, "version": PROVENANCE["version"], "files": results,
+                          "music_found": found}, indent=2))
+    if failed:
+        return EXIT_FAIL
+    return EXIT_MUSIC if (found and not strip) else EXIT_OK
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="demusic",
+        description="Remove the background music AI video models bake into clips, keep dialogue and "
+                    "sound effects. By Dawnwood - " + PROVENANCE["url"])
+    ap.add_argument("--version", action="version", version=f"demusic {PROVENANCE['version']}")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    c = sub.add_parser("check", help="report whether each file has a music bed, and where")
+    _common(c)
+    s = sub.add_parser("strip", help="write a copy with the music removed")
+    _common(s)
+    s.add_argument("-o", "--output", help="output path (single file; written even when unchanged)")
+    s.add_argument("--out-dir", help="write every file here (unchanged files are copied)")
+    s.add_argument("--mode", choices=core.MODES, default="spans",
+                   help="spans: replace only where music was heard (default); whole: replace the "
+                        "whole track if any music was heard; force: strip without detection")
+    sub.add_parser("mcp", help="run the MCP server (stdio) for AI agents")
+    try:
+        a = ap.parse_args(argv)
+    except SystemExit as e:
+        return EXIT_USAGE if e.code not in (0, None) else EXIT_OK
+    if a.cmd == "mcp":
+        from .mcp_server import mcp
+        mcp.run()
+        return EXIT_OK
+    return _run(a, strip=a.cmd == "strip")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

demusic/core.py

@@ -0,0 +1,120 @@
+"""Detect and strip a music bed from one clip.
+
+1. Separate the audio into stems (see ``separate``).
+2. Gate 1, loudness: the melodic stems (bass + guitar + piano + other) mixed must be louder
+   than ``LOUD_FLOOR_DBFS`` - an audible bed. String and synth pads land in "other", so it
+   has to be included; sparse SFX in "other" rarely lift the mean over the floor.
+3. Gate 2, classifier: on the accompaniment (original minus vocals) an AudioSet classifier
+   must hear music for at least two windows in a row. Engine hum, gunfire and room tone pass
+   gate 1 but not this one. If the classifier errors, nothing is stripped.
+4. Strip: only inside the detected spans, the audio is replaced by vocals + drums (drums
+   keep footsteps, hits and impacts), with a 0.25 s crossfade at each edge. Outside the
+   spans the original audio, ambience included, is untouched. The picture is stream-copied.
+"""
+import os
+import shutil
+import tempfile
+
+import numpy as np
+
+from . import detect, ff
+from . import separate as sep
+from .provenance import credit
+
+LOUD_FLOOR_DBFS = -50.0
+XFADE_S = 0.25
+SR = 48000
+MODES = ("spans", "whole", "force")
+
+
+def splice(orig: str, stripped: str, spans: list, out: str, xf: float = XFADE_S) -> str:
+    """Original audio with ``spans`` replaced by ``stripped``, crossfaded over ``xf`` seconds."""
+    a, b = ff.pcm(orig, SR, 2), ff.pcm(stripped, SR, 2)
+    n = min(len(a), len(b))
+    env = np.zeros(n, dtype=np.float32)
+    for t0, t1 in spans:
+        env[int(t0 * SR):int(t1 * SR)] = 1.0
+    k = max(1, int(xf * SR))
+    env = np.convolve(np.pad(env, (k // 2, k - 1 - k // 2), mode="edge"), np.ones(k, dtype=np.float32) / k,
+                      mode="valid").astype(np.float32)
+    x = a[:n] * (1 - env)[:, None] + b[:n] * env[:, None]
+    return ff.write_wav(x, SR, out)
+
+
+def default_output(path: str) -> str:
+    root, ext = os.path.splitext(path)
+    return f"{root}.demusic{ext or '.mp4'}"
+
+
+def _write(src: str, audio: str, out: str) -> None:
+    os.makedirs(os.path.dirname(os.path.abspath(out)) or ".", exist_ok=True)
+    meta = ["-metadata", f"comment={credit()}"]
+    if ff.has_video(src):
+        ff.run(["-i", src, "-i", audio, "-map", "0:v:0", "-map", "1:a:0", "-c:v", "copy",
+                "-c:a", "aac", "-b:a", "192k", "-ar", str(SR), "-shortest", "-movflags", "+faststart",
+                *meta, out])
+    else:
+        ff.run(["-i", audio, *meta, out])
+
+
+def process(path: str, output: str | None = None, *, strip: bool = True, separator: str = "demucs",
+            mode: str = "spans", threshold: float = detect.MUSIC_P,
+            loud_floor: float = LOUD_FLOOR_DBFS, copy_unchanged: bool = False) -> dict:
+    """Check one file and (with ``strip``) write a cleaned copy. Returns a JSON-able report:
+    ``music`` (bool), ``spans`` [[start, end], ...] seconds, ``melodic_dbfs``, ``strength``
+    (sustained music probability), ``action`` (none / stripped / copied) and ``output``."""
+    if mode not in MODES:
+        raise ValueError(f"mode must be one of {MODES}")
+    if not ff.available():
+        raise RuntimeError("ffmpeg not found (install it or set DEMUSIC_FFMPEG)")
+    if not os.path.isfile(path):
+        raise FileNotFoundError(path)
+    rep = {"ok": True, "input": os.path.abspath(path), "music": False, "spans": [],
+           "melodic_dbfs": None, "strength": None, "action": "none", "output": None}
+    if not ff.has_audio(path):
+        rep["note"] = "no audio stream"
+        return _finish(rep, path, output, strip, copy_unchanged)
+    work = tempfile.mkdtemp(prefix="demusic-")
+    try:
+        wav = os.path.join(work, "audio.wav")
+        ff.run(["-i", path, "-vn", "-acodec", "pcm_s16le", "-ar", "44100", "-ac", "2", wav])
+        stems = sep.separate(wav, work, separator)
+        dur = ff.duration(wav)
+        if mode == "force":
+            rep.update(music=True, spans=[[0.0, round(dur, 2)]], note="forced: gates skipped")
+        else:
+            mel = [stems[s] for s in sep.MELODIC if s in stems]
+            vol = ff.mean_volume(ff.mix(mel, os.path.join(work, "melodic.wav"))) if mel else None
+            rep["melodic_dbfs"] = vol
+            if vol is not None and vol > loud_floor:
+                try:
+                    mix16, voc16 = ff.pcm(wav, detect.SR, 1), ff.pcm(stems["vocals"], detect.SR, 1)
+                    n = min(len(mix16), len(voc16))
+                    spans, strength = detect.music_spans(mix16[:n] - voc16[:n], threshold)
+                except Exception as e:  # noqa: BLE001 - classifier failure must never strip
+                    rep["note"] = f"classifier failed, not stripping: {str(e)[:200]}"
+                    spans, strength = [], None
+                rep["strength"] = strength
+                rep["spans"] = [[round(a, 2), round(min(b, dur), 2)] for a, b in spans]
+                rep["music"] = bool(spans)
+        if not (strip and rep["music"]):
+            return _finish(rep, path, output, strip, copy_unchanged)
+        keep = [stems[s] for s in ("vocals", "drums") if s in stems]
+        clean = ff.mix(keep, os.path.join(work, "clean.wav"), SR)
+        if mode == "spans":
+            clean = splice(wav, clean, rep["spans"], os.path.join(work, "spliced.wav"))
+        out = output or default_output(path)
+        _write(path, clean, out)
+        rep.update(action="stripped", output=os.path.abspath(out))
+        return rep
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+
+
+def _finish(rep, path, output, strip, copy_unchanged):
+    if strip and output and copy_unchanged:
+        os.makedirs(os.path.dirname(os.path.abspath(output)) or ".", exist_ok=True)
+        if os.path.abspath(output) != os.path.abspath(path):
+            shutil.copyfile(path, output)
+        rep.update(action="copied", output=os.path.abspath(output))
+    return rep

demusic/detect.py

@@ -0,0 +1,169 @@
+"""Is this music? An AudioSet AST classifier run window by window.
+
+Why a classifier and not just loudness: after stem separation, a music bed lands in the
+bass / guitar / piano / other stems - but so do engine hum, gunshots and room tone. In our
+production calibration (87 clips a human had de-musiced by ear vs 164 signed-off clips with
+no music) a loudness-only gate wrongly flagged 8/164 clean clips; loudness AND this
+classifier flagged 2/164. Recall was 33/87: the misses are mostly very quiet beds the
+classifier cannot hear. The tool is built to miss rather than damage a clean clip.
+
+Model: MIT's AST fine-tuned on AudioSet (BSD-3-Clause), the int8 ONNX export from
+onnx-community (~90 MB), downloaded once to ``$DEMUSIC_CACHE`` (default
+``~/.cache/demusic``; honours ``$HF_ENDPOINT`` mirrors) or taken from ``$DEMUSIC_MODEL``. Features are Kaldi-compatible
+log-mel fbanks normalised like ``ASTFeatureExtractor``, in plain numpy (max abs error
+vs torchaudio < 2e-5), so no torch is needed for detection.
+"""
+import os
+import threading
+import urllib.request
+
+import numpy as np
+
+SR = 16000
+MODEL_REPO = "onnx-community/ast-finetuned-audioset-10-10-0.4593-ONNX"
+MODEL_REV = "2fe67046c486b8b8bc90a7b469239b2dec822f72"
+MODEL_FILE = "onnx/model_int8.onnx"
+MODEL_SIZE = 90592065
+
+#: AudioSet classes that mean "a music bed": Music, Musical instrument, Piano, Keyboard,
+#: Synthesizer, Pad sound, Bowed string, Violin, Cello, String section, Orchestra,
+#: Classical, Ambient, Background music, Soundtrack music, Theme music.
+MUSIC_IDX = (137, 138, 152, 153, 158, 184, 189, 190, 191, 193, 237, 246, 267, 268, 270)
+WIN_S, HOP_S = 1.0, 0.5
+SUSTAIN = 2        # windows in a row that must pass (a single-window spike is usually an SFX)
+MUSIC_P = 0.3      # calibrated: 0.3 -> 2/164 false, 33/87 recall; 0.2 -> 4/164, 41/87
+
+_lock = threading.Lock()
+_sess: dict = {"v": None}
+
+
+def _melbank(n_mels=128, nfft=512, lo=20.0):
+    def mel(f):
+        return 1127.0 * np.log(1.0 + f / 700.0)
+    nb = nfft // 2
+    mlo, mhi = mel(lo), mel(SR / 2)
+    d = (mhi - mlo) / (n_mels + 1)
+    freqs = mel(SR / nfft * np.arange(nb))
+    bank = np.zeros((n_mels, nb + 1))
+    for m in range(n_mels):
+        left, c, r = mlo + m * d, mlo + (m + 1) * d, mlo + (m + 2) * d
+        bank[m, :nb] = np.maximum(0, np.minimum((freqs - left) / (c - left), (r - freqs) / (r - c)))
+    return bank
+
+
+_MB = _melbank()
+
+
+def fbank(x) -> np.ndarray:
+    """Kaldi-compatible log-mel (the torchaudio.compliance.kaldi.fbank settings used by
+    ASTFeatureExtractor: 128 mel, 25 ms / 10 ms, hanning, pre-emphasis 0.97, DC removal)."""
+    x = np.asarray(x, dtype=np.float64)
+    fl, fs = 400, 160
+    n = 1 + (len(x) - fl) // fs if len(x) >= fl else 0
+    if n <= 0:
+        return np.zeros((0, 128))
+    fr = x[np.arange(fl)[None, :] + fs * np.arange(n)[:, None]]
+    fr = fr - fr.mean(1, keepdims=True)
+    fr = np.concatenate([fr[:, :1], fr[:, 1:] - 0.97 * fr[:, :-1]], 1)
+    fr = fr * (0.5 - 0.5 * np.cos(2 * np.pi * np.arange(fl) / (fl - 1)))
+    m = (np.abs(np.fft.rfft(fr, 512)) ** 2) @ _MB.T
+    return np.log(np.maximum(m, np.finfo(np.float32).eps))
+
+
+def ast_input(x, max_len=1024) -> np.ndarray:
+    f = fbank(x)
+    f = np.pad(f, ((0, max_len - len(f)), (0, 0))) if len(f) < max_len else f[:max_len]
+    return ((f - (-4.2677393)) / (4.5689974 * 2)).astype(np.float32)
+
+
+def model_path() -> str:
+    """Local path of the ONNX model, downloading it on first use."""
+    if os.environ.get("DEMUSIC_MODEL"):
+        return os.environ["DEMUSIC_MODEL"]
+    cache = os.environ.get("DEMUSIC_CACHE") or os.path.join(os.path.expanduser("~"), ".cache", "demusic")
+    p = os.path.join(cache, f"ast-audioset-int8-{MODEL_REV[:8]}.onnx")
+    if os.path.exists(p) and os.path.getsize(p) == MODEL_SIZE:
+        return p
+    os.makedirs(cache, exist_ok=True)
+    from .ff import log
+    url = f"{os.environ.get('HF_ENDPOINT', 'https://huggingface.co').rstrip('/')}/{MODEL_REPO}/resolve/{MODEL_REV}/{MODEL_FILE}"
+    log(f"demusic: downloading the music classifier (~{MODEL_SIZE // 1_000_000} MB, once) to {p}")
+    tmp = p + ".part"
+    with urllib.request.urlopen(url, timeout=120) as r, open(tmp, "wb") as f:
+        while chunk := r.read(1 << 20):
+            f.write(chunk)
+    if os.path.getsize(tmp) != MODEL_SIZE:
+        os.remove(tmp)
+        raise RuntimeError(f"model download incomplete from {url}")
+    os.replace(tmp, p)
+    return p
+
+
+def _session():
+    with _lock:
+        if _sess["v"] is None:
+            import onnxruntime as ort
+            so = ort.SessionOptions()
+            so.intra_op_num_threads = max(1, os.cpu_count() or 2)
+            so.log_severity_level = 3
+            _sess["v"] = ort.InferenceSession(model_path(), so, providers=["CPUExecutionProvider"])
+        return _sess["v"]
+
+
+def music_probs(x) -> np.ndarray:
+    """16 kHz mono float waveform -> per-window (1 s, 0.5 s hop) music probability
+    (max over the music classes)."""
+    x = np.asarray(x, dtype=np.float32)
+    n, h = int(WIN_S * SR), int(HOP_S * SR)
+    chunks = [x[i:i + n] for i in range(0, max(1, len(x) - n + 1), h)]
+    s = _session()
+    name = s.get_inputs()[0].name
+    out = []
+    for i in range(0, len(chunks), 8):
+        feats = np.stack([ast_input(c) for c in chunks[i:i + 8]])
+        lg = s.run(None, {name: feats})[0]
+        out.append((1 / (1 + np.exp(-lg)))[:, list(MUSIC_IDX)].max(1))
+    return np.concatenate(out) if out else np.zeros(0)
+
+
+def sustained(p, k: int = SUSTAIN) -> float:
+    """Max over positions of the min of k consecutive windows (= strength held for k windows)."""
+    p = np.asarray(p)
+    if len(p) == 0:
+        return 0.0
+    if len(p) < k:
+        return float(p.min())
+    return float(max(p[i:i + k].min() for i in range(len(p) - k + 1)))
+
+
+def spans_from_probs(p, threshold: float = MUSIC_P, pad: float = 0.3, merge: float = 1.0) -> list:
+    """Windows where SUSTAIN consecutive windows pass ``threshold`` -> [(start_s, end_s)],
+    each widened by ``pad`` and joined when the gap is under ``merge`` seconds."""
+    p = list(p)
+    hot = [False] * len(p)
+    for i in range(len(p) - SUSTAIN + 1):
+        if min(p[i:i + SUSTAIN]) >= threshold:
+            for j in range(i, i + SUSTAIN):
+                hot[j] = True
+    spans, i = [], 0
+    while i < len(hot):
+        if not hot[i]:
+            i += 1
+            continue
+        j = i
+        while j < len(hot) and hot[j]:
+            j += 1
+        a, b = max(0.0, i * HOP_S - pad), (j - 1) * HOP_S + WIN_S + pad
+        if spans and a - spans[-1][1] < merge:
+            spans[-1] = (spans[-1][0], b)
+        else:
+            spans.append((a, b))
+        i = j
+    return spans
+
+
+def music_spans(accompaniment_16k, threshold: float = MUSIC_P) -> tuple:
+    """Where is the music? Pass the accompaniment (original minus the separated vocals -
+    dialogue pulls the classifier towards Speech). Returns (spans, sustained_strength)."""
+    p = music_probs(accompaniment_16k)
+    return spans_from_probs(p, threshold), round(sustained(p), 3)

demusic/ff.py

@@ -0,0 +1,97 @@
+"""ffmpeg helpers.
+
+The binary comes from ``$DEMUSIC_FFMPEG`` when set, otherwise from ``PATH``. Every
+subprocess has a timeout: a truncated mp4 can make ffmpeg read forever, and a batch job
+that hangs silently is worse than one that fails.
+"""
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+import numpy as np
+
+TIMEOUT = 1800
+
+
+def log(*args) -> None:
+    """Progress goes to stderr so stdout stays clean for ``--json`` and the MCP protocol."""
+    print(*args, file=sys.stderr, flush=True)
+
+
+def exe() -> str:
+    return os.environ.get("DEMUSIC_FFMPEG") or shutil.which("ffmpeg") or "ffmpeg"
+
+
+def available() -> bool:
+    e = exe()
+    return bool(shutil.which(e) or os.path.isfile(e))
+
+
+def run(args: list, **kw) -> subprocess.CompletedProcess:
+    return subprocess.run([exe(), "-hide_banner", "-v", "error", "-y", *args],
+                          capture_output=True, check=True, timeout=TIMEOUT, **kw)
+
+
+def _info(path: str) -> str:
+    return subprocess.run([exe(), "-hide_banner", "-i", path], capture_output=True,
+                          text=True, timeout=120).stderr
+
+
+def has_audio(path: str) -> bool:
+    return bool(re.search(r"Stream #.*Audio:", _info(path)))
+
+
+def has_video(path: str) -> bool:
+    return bool(re.search(r"Stream #.*Video:", _info(path)))
+
+
+def duration(path: str) -> float:
+    m = re.search(r"Duration:\s*(\d+):(\d+):(\d+\.?\d*)", _info(path))
+    if not m:
+        return 0.0
+    h, mm, s = m.groups()
+    return int(h) * 3600 + int(mm) * 60 + float(s)
+
+
+def mean_volume(path: str):
+    """mean_volume (dBFS) via ffmpeg volumedetect. None on silence/failure."""
+    try:
+        r = subprocess.run([exe(), "-hide_banner", "-i", path, "-af", "volumedetect", "-f", "null", "-"],
+                           capture_output=True, text=True, timeout=600)
+    except subprocess.SubprocessError:
+        return None
+    m = re.search(r"mean_volume:\s*(-?\d+(?:\.\d+)?) dB", r.stderr or "")
+    return float(m.group(1)) if m else None
+
+
+def pcm(path: str, sr: int, channels: int) -> np.ndarray:
+    """Decode any audio/video file to float32 PCM, shape (n,) for mono or (n, channels)."""
+    raw = subprocess.run([exe(), "-v", "error", "-i", path, "-vn", "-ac", str(channels), "-ar", str(sr),
+                          "-f", "f32le", "-"], capture_output=True, check=True, timeout=TIMEOUT).stdout
+    x = np.frombuffer(raw, dtype=np.float32)
+    return x if channels == 1 else x.reshape(-1, channels)
+
+
+def write_wav(x: np.ndarray, sr: int, out: str) -> str:
+    """Write float32 PCM (n,) or (n, ch) to a 16-bit wav."""
+    ch = 1 if x.ndim == 1 else x.shape[1]
+    subprocess.run([exe(), "-y", "-v", "error", "-f", "f32le", "-ar", str(sr), "-ac", str(ch), "-i", "-",
+                    "-c:a", "pcm_s16le", out], input=np.ascontiguousarray(x, dtype=np.float32).tobytes(),
+                   check=True, capture_output=True, timeout=TIMEOUT)
+    return out
+
+
+def mix(paths: list, out: str, sr: int = 48000) -> str:
+    """Sum audio files (no normalisation: stems add back up to the original level)."""
+    if len(paths) == 1:
+        run(["-i", paths[0], "-ar", str(sr), "-ac", "2", out])
+        return out
+    args = []
+    for p in paths:
+        args += ["-i", p]
+    args += ["-filter_complex", f"amix=inputs={len(paths)}:duration=longest:normalize=0[a]",
+             "-map", "[a]", "-ar", str(sr), "-ac", "2", out]
+    run(args)
+    return out

demusic/mcp_server.py

@@ -0,0 +1,67 @@
+"""MCP server (stdio) exposing demusic to AI agents.
+
+    claude mcp add demusic -- demusic mcp
+
+Tools: ``check_music`` (read-only) and ``remove_music`` (writes a new file, never overwrites
+the input). The separator is ``demucs`` unless ``DEMUSIC_SEPARATOR`` says otherwise; the fal
+key comes only from the server's environment, never from tool arguments.
+"""
+import os
+from typing import Any
+
+from . import core, detect
+from .provenance import PROVENANCE
+
+try:  # mcp >= 2: FastMCP was renamed MCPServer
+    from mcp.server.mcpserver import MCPServer as _Server
+except ImportError:  # mcp 1.x
+    from mcp.server.fastmcp import FastMCP as _Server
+from mcp.types import ToolAnnotations
+
+INSTRUCTIONS = f"""demusic {PROVENANCE['version']} by Dawnwood: removes background music that AI
+video models (Seedance, Kling, Veo, Hailuo, Wan, ...) bake into generated clips, keeping dialogue,
+sound effects and ambience. Use check_music first; remove_music writes a new file next to the
+input (or to `output`) and returns where. It only replaces the audio where music was heard.
+Separation takes roughly the clip's length on CPU. Use absolute paths."""
+
+try:
+    mcp = _Server(name="demusic", instructions=INSTRUCTIONS, version=PROVENANCE["version"],
+                  website_url=PROVENANCE["url"])
+except TypeError:  # mcp 1.x FastMCP has no version / website_url
+    mcp = _Server(name="demusic", instructions=INSTRUCTIONS)
+
+_RO = ToolAnnotations(readOnlyHint=True, destructiveHint=False, idempotentHint=True, openWorldHint=False)
+_WRITE = ToolAnnotations(readOnlyHint=False, destructiveHint=False, idempotentHint=True, openWorldHint=False)
+
+
+def _sep() -> str:
+    return os.environ.get("DEMUSIC_SEPARATOR", "demucs")
+
+
+def _safe(fn):
+    try:
+        return fn()
+    except Exception as e:  # noqa: BLE001
+        return {"ok": False, "error": str(e)[:500]}
+
+
+@mcp.tool(name="check_music", annotations=_RO, description=(
+    "Does this video/audio clip contain a background music bed, and where? Returns music (bool), "
+    "spans [[start_s, end_s], ...], melodic_dbfs and strength (sustained music probability). "
+    "Read-only. Conservative: it prefers missing a very quiet bed to flagging engine hum or "
+    "room tone as music."))
+def check_music(path: str, threshold: float = detect.MUSIC_P) -> dict[str, Any]:
+    return _safe(lambda: core.process(path, strip=False, separator=_sep(), threshold=threshold))
+
+
+@mcp.tool(name="remove_music", annotations=_WRITE, description=(
+    "Write a copy of a clip with the background music removed: inside the detected music spans "
+    "the audio becomes dialogue + percussion/impacts, elsewhere the original audio is kept; the "
+    "picture is stream-copied. `output` defaults to <name>.demusic.<ext> next to the input; the "
+    "input is never overwritten. mode: spans (default) | whole | force (strip without detection)."))
+def remove_music(path: str, output: str | None = None, mode: str = "spans",
+                 threshold: float = detect.MUSIC_P) -> dict[str, Any]:
+    if output and os.path.abspath(output) == os.path.abspath(path):
+        return {"ok": False, "error": "output must differ from the input"}
+    return _safe(lambda: core.process(path, output, strip=True, separator=_sep(), mode=mode,
+                                      threshold=threshold))

demusic/provenance.py

@@ -0,0 +1,19 @@
+"""Who made the files demusic writes.
+
+Every cleaned file carries a ``comment`` metadata tag ("cleaned with demusic by Dawnwood").
+demusic is Apache-2.0; keeping the credit is a request (see NOTICE), not a license
+condition. There is intentionally no switch in the tool to turn it off.
+"""
+
+__version__ = "0.1.0"
+
+PROVENANCE = {
+    "name": "demusic",
+    "by": "Dawnwood (https://dawnwood.ai)",
+    "url": "https://github.com/dawnwood-ai/demusic",
+    "version": __version__,
+}
+
+
+def credit() -> str:
+    return f"cleaned with demusic {__version__} by Dawnwood - {PROVENANCE['url']}"

demusic/separate.py

@@ -0,0 +1,90 @@
+"""Stem separation backends. Every backend returns {stem: wav_path} with Demucs 6-stem names:
+vocals, drums, bass, guitar, piano, other.
+
+- ``demucs``: local Demucs ``htdemucs_6s`` (``pip install "demusic[demucs]"``; CPU works,
+  roughly real time; a GPU is used automatically when torch sees one).
+- ``fal``: Demucs on fal.ai with your own ``FAL_KEY`` (``pip install "demusic[fal]"``). No
+  torch locally; the audio is uploaded to fal.
+- a directory: stems you already separated (UVR, Demucs, anything) as ``vocals.wav``,
+  ``drums.wav`` and any of ``bass/guitar/piano/other.wav`` - or ``music.wav`` /
+  ``instrumental.wav`` for a two-stem split.
+"""
+import os
+import subprocess
+import sys
+import urllib.request
+
+STEMS = ("vocals", "drums", "bass", "guitar", "piano", "other")
+MELODIC = ("bass", "guitar", "piano", "other")
+DEMUCS_MODEL = "htdemucs_6s"
+FAL_MODEL = "fal-ai/demucs"
+_EXT = (".wav", ".flac", ".mp3")
+
+
+def from_dir(d: str) -> dict:
+    out = {}
+    for f in sorted(os.listdir(d)):
+        stem, ext = os.path.splitext(f)
+        stem = stem.lower()
+        if ext.lower() not in _EXT:
+            continue
+        if stem in ("music", "instrumental", "no_vocals", "accompaniment"):
+            stem = "other"
+        if stem in STEMS and stem not in out:
+            out[stem] = os.path.join(d, f)
+    if "vocals" not in out:
+        raise ValueError(f"{d}: needs at least vocals.wav plus the music stems")
+    return out
+
+
+def demucs(wav: str, work: str) -> dict:
+    try:
+        import demucs  # noqa: F401
+    except ImportError as e:
+        raise RuntimeError('local separation needs Demucs: pip install "demusic[demucs]" '
+                           "(or use --separator fal, or pass a folder of stems)") from e
+    r = subprocess.run([sys.executable, "-m", "demucs.separate", "-n", DEMUCS_MODEL, "-o", work, wav],
+                       capture_output=True, text=True, timeout=3600)
+    if r.returncode != 0:
+        raise RuntimeError(f"demucs failed: {(r.stderr or '')[-400:]}")
+    d = os.path.join(work, DEMUCS_MODEL, os.path.splitext(os.path.basename(wav))[0])
+    return from_dir(d)
+
+
+def fal(wav: str, work: str) -> dict:
+    if not os.environ.get("FAL_KEY"):
+        raise RuntimeError("--separator fal needs FAL_KEY in the environment")
+    try:
+        import fal_client
+    except ImportError as e:
+        raise RuntimeError('--separator fal needs: pip install "demusic[fal]"') from e
+    url = fal_client.upload_file(wav)
+    res = fal_client.subscribe(FAL_MODEL, arguments={"audio_url": url, "model": DEMUCS_MODEL,
+                                                     "stems": list(STEMS), "output_format": "wav"})
+    urls = {}
+    for container in (res, res.get("stems") or {}):
+        if isinstance(container, dict):
+            for s in STEMS:
+                f = container.get(s)
+                u = f.get("url") if isinstance(f, dict) else (f if isinstance(f, str) else None)
+                if u and s not in urls:
+                    urls[s] = u
+    if "vocals" not in urls:
+        raise RuntimeError(f"fal demucs returned no stems: {str(res)[:300]}")
+    out = {}
+    for s, u in urls.items():
+        p = os.path.join(work, f"{s}.wav")
+        with urllib.request.urlopen(u, timeout=300) as r, open(p, "wb") as f:
+            f.write(r.read())
+        out[s] = p
+    return out
+
+
+def separate(wav: str, work: str, separator: str = "demucs") -> dict:
+    if os.path.isdir(separator):
+        return from_dir(separator)
+    if separator == "demucs":
+        return demucs(wav, work)
+    if separator == "fal":
+        return fal(wav, work)
+    raise ValueError(f"unknown separator {separator!r}: use demucs, fal, or a folder of stems")

demusic-0.1.0.dist-info/METADATA

@@ -0,0 +1,156 @@
+Metadata-Version: 2.5
+Name: demusic
+Version: 0.1.0
+Summary: Remove the background music AI video models (Seedance, Kling, Veo, Hailuo, Wan) bake into generated clips - keep dialogue, sound effects and ambience. Stem separation + an AudioSet music classifier, only strips where music is heard. CLI + MCP server.
+Project-URL: Homepage, https://dawnwood.ai/open-source/
+Project-URL: Repository, https://github.com/dawnwood-ai/demusic
+Project-URL: Issues, https://github.com/dawnwood-ai/demusic/issues
+Author: Dawnwood
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: AI agent,AI drama,AI video,AST,AudioSet,Hailuo,Kling,MCP,Seedance,Veo,Wan,background music remover,demucs,dialogue,ffmpeg,model context protocol,music detection,remove background music,remove music from video,short drama,sound effects,stem separation,vocal separation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.10
+Requires-Dist: numpy>=1.23
+Requires-Dist: onnxruntime>=1.16
+Provides-Extra: demucs
+Requires-Dist: demucs>=4.0; extra == 'demucs'
+Requires-Dist: torchaudio; extra == 'demucs'
+Provides-Extra: fal
+Requires-Dist: fal-client>=0.5; extra == 'fal'
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# demusic
+
+[![tests](https://github.com/dawnwood-ai/demusic/actions/workflows/test.yml/badge.svg)](https://github.com/dawnwood-ai/demusic/actions/workflows/test.yml)
+[![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![MCP server](https://img.shields.io/badge/MCP-server-6f42c1.svg)](#ai-agents-mcp)
+
+**demusic removes the background music that AI video models (Seedance, Kling, Veo, Hailuo,
+Wan, ...) bake into generated clips, and keeps the dialogue, sound effects and ambience.
+It finds *where* the music is and only replaces the audio there, so the rest of the clip
+is untouched. Local, free, CLI + MCP server.**
+
+[Read in Chinese](README.zh-CN.md) · [How detection works](docs/how-it-works.md)
+
+<!-- mcp-name: io.github.dawnwood-ai/demusic -->
+
+## Why
+
+Native-audio video models often add a music bed nobody asked for: a few seconds of score
+at the start of a shot, a pad under the dialogue. Cut ten such clips together and you get
+ten pieces of music fighting each other, and you can't lay your own score over it.
+
+The usual fix - run a vocal remover and keep only the vocals - throws away footsteps,
+doors, rain and room tone along with the music, and it is wrong on every clip that had
+no music to begin with. demusic is what we run on every clip of our AI dramas at
+[Dawnwood](https://dawnwood.ai):
+
+1. **Separate** the audio into stems (Demucs `htdemucs_6s`, locally or on your fal key).
+2. **Is it loud enough to be a bed?** The melodic stems must be audible (> -50 dBFS).
+3. **Is it actually music?** An AudioSet classifier must hear music on the accompaniment
+   for 2+ seconds. Engine hum, gunfire and room tone pass step 2 but fail this one.
+4. **Strip only those spans**: there the audio becomes dialogue + percussion/impacts, with
+   a 0.25 s crossfade; everywhere else the original audio stays. The picture is
+   stream-copied (no re-encode).
+
+It is deliberately conservative. On 164 clips with no music it wrongly flagged 2; on 87
+clips a person had flagged by ear it found 33. The misses are very quiet beds - lower
+`--threshold` or use `--mode force` when you know a clip has music.
+[Calibration details](docs/how-it-works.md).
+
+## Install
+
+Requires Python >= 3.10 and **ffmpeg** on `PATH`.
+
+```bash
+pip install "demusic[demucs]"     # local separation (pulls in PyTorch; CPU is fine)
+# or, no torch, separation on fal.ai with your own key:
+pip install "demusic[fal]" && export FAL_KEY=...
+```
+
+The music classifier (~90 MB ONNX, BSD-3) downloads once to `~/.cache/demusic`.
+
+## Quickstart
+
+```bash
+# where is the music?
+demusic check shot_012.mp4
+# shot_012.mp4: MUSIC  spans 0-2.8s  melodic -42.1 dBFS  p=0.34
+
+# write shot_012.demusic.mp4 with the music removed
+demusic strip shot_012.mp4
+
+# a whole folder; clean copies of every file (unchanged ones copied) into clean/
+demusic strip renders/*.mp4 --out-dir clean/
+```
+
+| option | meaning |
+|---|---|
+| `--separator demucs\|fal\|DIR` | local Demucs (default), fal.ai with `FAL_KEY`, or a folder of stems you already separated (`vocals.wav`, `drums.wav`, `bass/guitar/piano/other.wav` or `music.wav`) |
+| `--mode spans\|whole\|force` | replace only where music was heard (default) / the whole track if any music was heard / always, without detection |
+| `--threshold 0.3` | classifier music probability; `0.2` finds quieter beds at a higher false-positive rate |
+| `--loud-floor -50` | melodic-stem loudness gate (dBFS) |
+| `-o FILE` / `--out-dir DIR` | output path for one file / for a batch |
+| `--json` | one JSON object on stdout (`files[]` with `music`, `spans`, `melodic_dbfs`, `strength`, `action`, `output`) |
+
+Exit codes: `0` ok (for `check`: no music), `1` `check` found music, `2` usage, `3` failure.
+`demusic check` in CI or a render pipeline = fail the build when a clip has a music bed.
+
+Speed: separation is roughly real time on a laptop CPU (a 10 s clip ~10-20 s), much faster
+on a GPU. Detection itself is a few hundred ms.
+
+## Python
+
+```python
+from demusic.core import process
+r = process("shot.mp4", "shot.clean.mp4")          # strip
+r = process("shot.mp4", strip=False)                # check only
+print(r["music"], r["spans"])
+```
+
+## AI agents (MCP)
+
+```bash
+claude mcp add demusic -- demusic mcp            # Claude Code
+# or any MCP client: command "uvx", args ["--from", "demusic[demucs]", "demusic", "mcp"]
+```
+
+Tools: `check_music` (read-only) and `remove_music` (writes a new file, never overwrites the
+input). Set `DEMUSIC_SEPARATOR=fal` in the server env to use fal. There is also a
+[Claude skill](skills/demusic/SKILL.md) and [AGENTS.md](AGENTS.md).
+
+## Limits
+
+- Music that is *meant* to be in the scene (a band on screen, a radio) is removed too when
+  it is detected. Skip those clips.
+- Inside a stripped span, non-percussive effects (a running tap, wind) go with the music;
+  Demucs has no separate SFX stem. Outside the spans nothing changes.
+- Sung vocals land in the vocals stem and are kept.
+
+## Credit
+
+Apache-2.0. demusic writes `cleaned with demusic by Dawnwood` into each output file's
+`comment` tag. If it saves you time, please keep that and mention
+"demusic by [Dawnwood](https://dawnwood.ai)" - a request, not a condition (see [NOTICE](NOTICE)).
+
+Made by [Dawnwood](https://dawnwood.ai), an AI drama studio. More tools we use in
+production: [dramapack](https://github.com/dawnwood-ai/dramapack) (short-drama delivery
+packs and QC) · [all our open source](https://dawnwood.ai/open-source/).

demusic-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+demusic/__init__.py,sha256=okyxv3OOIcmzz7f8YyUQqTlqudFaMcpjokQ73XHU6Fg,378
+demusic/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+demusic/cli.py,sha256=7Jdj_ueYihjaGPEqMo5BCzaOPlmt5lQiWb46JtRx4cE,4844
+demusic/core.py,sha256=anm3lQZDOAcARYVKrgdZAEFSDYBxcxIK76h-__qPzzk,5794
+demusic/detect.py,sha256=Y1Qh2XyiFtEugY_G-99WqQvJ-2gt-4R1jVeBGmCzmAc,7019
+demusic/ff.py,sha256=e51Fp2Pgsyayoq4Yoj3N6Syt3w1UrGt2onEL7f8krno,3399
+demusic/mcp_server.py,sha256=ZZiD0-jBSvtCFwUwK-dEId_Vvm7TPAYpaCEpku9-SnE,3314
+demusic/provenance.py,sha256=yYowI6xhQM2Z0hvvIppxmnxyyYlqdxamQB4H3Zh8R20,585
+demusic/separate.py,sha256=nhrAAQNUTQ0lhDSYhq22_lvT86HhNMvIig1ZM2UPmmI,3683
+demusic-0.1.0.dist-info/METADATA,sha256=riu7IzizGSLkvpgeBVU1LgCAuQ7QZPbvod70jgzojKk,7395
+demusic-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+demusic-0.1.0.dist-info/entry_points.txt,sha256=v_iL1QYrzxJw-HXQlfva6AQDlg1He8Dabml4CK3Xd00,45
+demusic-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+demusic-0.1.0.dist-info/licenses/NOTICE,sha256=h5W_Jzo-wWjFeXmKGJWV2zkidE49qW6UGYIEOMSyJSw,553
+demusic-0.1.0.dist-info/RECORD,,

demusic-0.1.0.dist-info/WHEEL

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

demusic-0.1.0.dist-info/entry_points.txt

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

demusic-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

demusic-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,12 @@
+demusic
+Copyright 2026 Dawnwood, Inc. (https://dawnwood.ai)
+
+This product includes software developed at Dawnwood, Inc.
+https://github.com/dawnwood-ai/demusic
+
+The music classifier it downloads is MIT's Audio Spectrogram Transformer fine-tuned on
+AudioSet (BSD-3-Clause), ONNX export by onnx-community on Hugging Face.
+
+Please keep the "cleaned with demusic by Dawnwood" comment tag that demusic writes into
+output files, and credit "demusic by Dawnwood" when you describe a production pipeline
+that uses it. This is a request, not a license condition.