pycodedj 0.1.0__py3-none-any.whl

pycodedj/__init__.py

@@ -0,0 +1,3 @@
+"""PyCodeDJ — live coding orchestrator that maps Python code structure to music."""
+
+__version__ = "0.1.0"

pycodedj/__main__.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .block_parser import parse_blocks
+from .engine import Engine
+from .osc_bridge import OscBridge, OscEndpoint, OscError
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="pycodedj")
+    sub = parser.add_subparsers(dest="command")
+
+    eval_p = sub.add_parser("eval", help="Evaluate a loop block and send OSC parameters")
+    eval_p.add_argument(
+        "target",
+        metavar="FILE::LOOP",
+        help="Path to source file and loop name, separated by ::",
+    )
+    eval_p.add_argument("--sc-host", default="127.0.0.1", help="SuperCollider host")
+    eval_p.add_argument("--sc-port", default=57120, type=int, help="SuperCollider port")
+
+    watch_p = sub.add_parser("watch", help="Watch a file and re-eval all loops on save")
+    watch_p.add_argument("file", metavar="FILE", help="Source file to watch")
+    watch_p.add_argument("--sc-host", default="127.0.0.1", help="SuperCollider host")
+    watch_p.add_argument("--sc-port", default=57120, type=int, help="SuperCollider port")
+    watch_p.add_argument(
+        "--debounce", default=0.3, type=float,
+        metavar="SECS", help="Debounce interval in seconds (default: 0.3)",
+    )
+
+    return parser
+
+
+def _print_params(loop_name: str, params: object) -> None:
+    from .mapper import MusicParams
+    if not isinstance(params, MusicParams):
+        return
+    print(
+        f"[pycodedj] {loop_name}"
+        f"  cutoff={params.cutoff:.0f}Hz"
+        f"  lfo={params.lfo_rate:.2f}Hz"
+        f"  reverb={params.reverb_mix:.2f}"
+        f"  voices={params.voice_count}"
+    )
+
+
+def _cmd_eval(args: argparse.Namespace) -> int:
+    if "::" not in args.target:
+        sys.stderr.write(f"[pycodedj] invalid target format (expected FILE::LOOP): {args.target}\n")
+        return 1
+
+    file_path, loop_name = args.target.split("::", 1)
+    path = Path(file_path)
+
+    if not path.exists():
+        sys.stderr.write(f"[pycodedj] file not found: {file_path}\n")
+        return 1
+
+    source = path.read_text(encoding="utf-8")
+    blocks = parse_blocks(source)
+    block_map = {b.name: b for b in blocks}
+
+    if loop_name not in block_map:
+        available = ", ".join(block_map.keys()) or "(none)"
+        sys.stderr.write(
+            f"[pycodedj] loop '{loop_name}' not found in {file_path}. "
+            f"Available: {available}\n"
+        )
+        return 1
+
+    try:
+        bridge = OscBridge(audio=OscEndpoint(host=args.sc_host, port=args.sc_port))
+        engine = Engine(bridge=bridge)
+        params = engine.eval_block(block_map[loop_name])
+    except OscError as e:
+        sys.stderr.write(f"[pycodedj] OSC error: {e}\n")
+        return 1
+
+    if params is not None:
+        _print_params(loop_name, params)
+        return 0
+    return 1
+
+
+def _cmd_watch(args: argparse.Namespace) -> int:
+    path = Path(args.file)
+    if not path.exists():
+        sys.stderr.write(f"[pycodedj] file not found: {args.file}\n")
+        return 1
+
+    try:
+        from .watcher import watch
+    except ImportError as e:
+        sys.stderr.write(f"[pycodedj] {e}\n")
+        return 1
+
+    try:
+        bridge = OscBridge(audio=OscEndpoint(host=args.sc_host, port=args.sc_port))
+    except OscError as e:
+        sys.stderr.write(f"[pycodedj] OSC error: {e}\n")
+        return 1
+
+    engine = Engine(bridge=bridge)
+
+    def _on_eval(file_path: str, loop_count: int) -> None:
+        print(f"[pycodedj] reloaded {Path(file_path).name} ({loop_count} loop(s))")
+
+    print(f"[pycodedj] watching {path} — save to reload (Ctrl+C to stop)")
+    watch(str(path), engine, debounce=args.debounce, on_eval=_on_eval)
+    return 0
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    if args.command == "eval":
+        sys.exit(_cmd_eval(args))
+    elif args.command == "watch":
+        sys.exit(_cmd_watch(args))
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

pycodedj/analyzer.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import ast
+import io
+import tokenize
+from dataclasses import dataclass
+
+
+@dataclass
+class CodeFeatures:
+    max_depth: int
+    control_flow_count: int
+    function_count: int
+    comment_ratio: float
+
+
+# ブロック構造ノードだけをネスト深さとしてカウントする。
+# BinOp・Call など式ノードは含めない（式の複雑さではなく制御構造の深さを測る）。
+_BLOCK_NODES = (
+    ast.If, ast.For, ast.While, ast.With,
+    ast.Try, ast.FunctionDef, ast.AsyncFunctionDef,
+    ast.ClassDef, ast.ExceptHandler,
+)
+
+
+def _ast_depth(node: ast.AST, current: int = 0) -> int:
+    children = list(ast.iter_child_nodes(node))
+    if not children:
+        return current
+    next_depth = current + 1 if isinstance(node, _BLOCK_NODES) else current
+    return max(_ast_depth(child, next_depth) for child in children)
+
+
+def _count_nodes(tree: ast.AST, *types: type) -> int:
+    return sum(isinstance(node, types) for node in ast.walk(tree))
+
+
+def _comment_ratio(source: str) -> float:
+    tokens = tokenize.generate_tokens(io.StringIO(source).readline)
+    comment_count = 0
+    try:
+        for tok in tokens:
+            if tok.type == tokenize.COMMENT:
+                comment_count += 1
+    except tokenize.TokenError:
+        pass
+
+    total_non_blank = sum(1 for line in source.splitlines() if line.strip())
+    if total_non_blank == 0:
+        return 0.0
+    return comment_count / total_non_blank
+
+
+def analyze(source: str) -> CodeFeatures:
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        raise
+
+    return CodeFeatures(
+        max_depth=_ast_depth(tree),
+        control_flow_count=_count_nodes(tree, ast.If, ast.For, ast.While),
+        function_count=_count_nodes(tree, ast.FunctionDef, ast.AsyncFunctionDef),
+        comment_ratio=_comment_ratio(source),
+    )

pycodedj/block_parser.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+_MARKER_RE = re.compile(r"^#\s*@loop\s+(\w+)(?:\s+interval=([\d.]+))?")
+_DEFAULT_INTERVAL = 1.0
+
+
+@dataclass
+class LoopBlock:
+    name: str
+    interval: float
+    source: str
+
+
+def parse_blocks(source: str) -> list[LoopBlock]:
+    blocks: list[LoopBlock] = []
+    current_name: str | None = None
+    current_interval: float = _DEFAULT_INTERVAL
+    current_lines: list[str] = []
+
+    for line in source.splitlines(keepends=True):
+        m = _MARKER_RE.match(line)
+        if m:
+            if current_name is not None:
+                blocks.append(LoopBlock(
+                    name=current_name,
+                    interval=current_interval,
+                    source="".join(current_lines),
+                ))
+            current_name = m.group(1)
+            current_interval = float(m.group(2)) if m.group(2) else _DEFAULT_INTERVAL
+            current_lines = []
+        elif current_name is not None:
+            current_lines.append(line)
+
+    if current_name is not None:
+        blocks.append(LoopBlock(
+            name=current_name,
+            interval=current_interval,
+            source="".join(current_lines),
+        ))
+
+    return blocks

pycodedj/engine.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+
+from .analyzer import analyze
+from .block_parser import LoopBlock
+from .mapper import MusicParams, map_features
+from .osc_bridge import OscBridge, OscError
+
+
+@dataclass
+class Engine:
+    bridge: OscBridge
+    _loops: dict[str, MusicParams] = field(default_factory=dict, init=False, repr=False)
+
+    def eval_block(self, block: LoopBlock) -> MusicParams | None:
+        try:
+            features = analyze(block.source)
+            params = map_features(features)
+            self.bridge.send_params(block.name, params)
+            self._loops[block.name] = params
+            return params
+        except SyntaxError as e:
+            sys.stderr.write(f"[pycodedj] syntax error ({block.name}): {e}\n")
+        except OscError as e:
+            sys.stderr.write(f"[pycodedj] OSC send failed ({block.name}): {e}\n")
+        return None
+
+    def stop_loop(self, name: str) -> None:
+        self._loops.pop(name, None)
+        stop_params = MusicParams(cutoff=200.0, lfo_rate=0.1, reverb_mix=0.0, voice_count=0)
+        self.bridge.send_params(name, stop_params)
+
+    def list_loops(self) -> list[str]:
+        return list(self._loops.keys())

pycodedj/examples/club_set.py

@@ -0,0 +1,71 @@
+# PyCodeDJ club-style demo.
+#
+# Load sc/synths.scd in SuperCollider, then bring parts in and out:
+#   pycodedj eval examples/club_set.py::sub_bass
+#   pycodedj eval examples/club_set.py::hat_engine
+#   pycodedj eval examples/club_set.py::neon_stab
+#   pycodedj eval examples/club_set.py::acid_lead
+#   pycodedj eval examples/club_set.py::warehouse_air
+#
+# These blocks are meant as code-structure performance material. Edit and save
+# them live, then re-run eval for a loop to push a new sound shape.
+
+
+# @loop sub_bass interval=1.0
+def sub_bass():
+    pulse = [1, 0, 0, 1, 0, 1, 0, 0]
+    for step in range(8):
+        if pulse[step]:
+            if step in (0, 5):
+                drive = "heavy"
+            else:
+                drive = "tight"
+            _ = drive
+
+
+# @loop hat_engine interval=0.25
+def hat_engine():
+    grid = range(16)
+    for tick in grid:
+        if tick % 2 == 0:
+            accent = "closed"
+        if tick in (3, 7, 11, 15):
+            accent = "open"
+        _ = accent
+
+
+# @loop neon_stab interval=2.0
+def neon_stab():
+    def chord_root():
+        return "minor"
+
+    def chord_fifth():
+        return "pressure"
+
+    def chord_seventh():
+        return "glow"
+
+    return chord_root(), chord_fifth(), chord_seventh()
+
+
+# @loop acid_lead interval=0.5
+def acid_lead():
+    pattern = [0, 3, 7, 10, 12, 10, 7, 3]
+    for note in pattern:
+        if note > 9:
+            for slide in range(2):
+                if slide == 1:
+                    bend = "up"
+                else:
+                    bend = "down"
+                _ = bend
+
+
+# @loop warehouse_air interval=4.0
+# smoke above the kick
+# late reflections
+# concrete room tail
+# crowd heat
+# blue strobes
+def warehouse_air():
+    pass

pycodedj/examples/demo.py

@@ -0,0 +1,23 @@
+# PyCodeDJ demo — run each block independently:
+#   pycodedj eval examples/demo.py::bass
+#   pycodedj eval examples/demo.py::melody
+#   pycodedj eval examples/demo.py::pad
+
+# @loop bass interval=2.0
+def bass():
+    for i in range(8):
+        if i % 2 == 0:
+            pass
+
+# @loop melody interval=0.5
+def melody():
+    x = 1
+    y = 2
+    return x + y
+
+# @loop pad interval=4.0
+# ここに余白を置く
+# もう少し置く
+# 静寂も音楽
+def pad():
+    pass

pycodedj/examples/hello_sc.py

@@ -0,0 +1,29 @@
+"""Single OSC ping to verify SuperCollider connectivity.
+
+Usage:
+    python examples/hello_sc.py
+    python examples/hello_sc.py --host 127.0.0.1 --port 57120
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from pycodedj.mapper import MusicParams
+from pycodedj.osc_bridge import OscBridge, OscEndpoint
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", default=57120, type=int)
+    args = parser.parse_args()
+
+    bridge = OscBridge(audio=OscEndpoint(host=args.host, port=args.port))
+    params = MusicParams(cutoff=1000.0, lfo_rate=0.5, reverb_mix=0.2, voice_count=1)
+    bridge.send_params("hello", params)
+    print(f"Sent OSC to {args.host}:{args.port} — loop 'hello'")
+
+
+if __name__ == "__main__":
+    main()

pycodedj/mapper.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .analyzer import CodeFeatures
+
+_CUTOFF_MIN = 200.0
+_CUTOFF_MAX = 4000.0
+_CUTOFF_DEPTH_MAX = 10
+
+_LFO_MIN = 0.1
+_LFO_MAX = 5.0
+_LFO_COUNT_MAX = 10
+
+_REVERB_MIN = 0.0
+_REVERB_MAX = 0.8
+
+_VOICE_MIN = 1
+_VOICE_MAX = 4
+
+
+@dataclass
+class MusicParams:
+    cutoff: float
+    lfo_rate: float
+    reverb_mix: float
+    voice_count: int
+
+
+def _lerp(value: float, in_max: float, out_min: float, out_max: float) -> float:
+    t = min(max(value / in_max, 0.0), 1.0)
+    return out_min + t * (out_max - out_min)
+
+
+def map_features(features: CodeFeatures) -> MusicParams:
+    cutoff = _lerp(features.max_depth, _CUTOFF_DEPTH_MAX, _CUTOFF_MIN, _CUTOFF_MAX)
+    lfo_rate = _lerp(features.control_flow_count, _LFO_COUNT_MAX, _LFO_MIN, _LFO_MAX)
+    reverb_mix = _lerp(features.comment_ratio, 1.0, _REVERB_MIN, _REVERB_MAX)
+    voice_count = min(max(features.function_count, _VOICE_MIN), _VOICE_MAX)
+
+    return MusicParams(
+        cutoff=cutoff,
+        lfo_rate=lfo_rate,
+        reverb_mix=reverb_mix,
+        voice_count=voice_count,
+    )

pycodedj/osc_bridge.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from pythonosc import udp_client
+
+if TYPE_CHECKING:
+    from .mapper import MusicParams
+
+
+class OscError(Exception):
+    """OSC クライアントの初期化・送信失敗を表す例外。"""
+
+
+@dataclass
+class OscEndpoint:
+    host: str
+    port: int
+    _client: udp_client.SimpleUDPClient = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        try:
+            self._client = udp_client.SimpleUDPClient(self.host, self.port)
+        except (OSError, AttributeError) as e:
+            raise OscError(f"failed to create OSC client ({self.host}:{self.port}): {e}") from e
+
+    def send(self, address: str, *args: object) -> None:
+        try:
+            self._client.send_message(address, list(args))
+        except (OSError, AttributeError) as e:
+            raise OscError(f"failed to send OSC message to {address}: {e}") from e
+
+
+@dataclass
+class OscBridge:
+    audio: OscEndpoint
+    visual: OscEndpoint | None = None
+
+    def send_params(self, name: str, params: "MusicParams") -> None:
+        base = f"/pycodedj/loop/{name}"
+        # voice_count を先に送り SC 側でシンセを起動してから各パラメーターを適用させる
+        self.audio.send(f"{base}/voice_count", params.voice_count)
+        self.audio.send(f"{base}/cutoff", params.cutoff)
+        self.audio.send(f"{base}/lfo_rate", params.lfo_rate)
+        self.audio.send(f"{base}/reverb", params.reverb_mix)
+        if self.visual is not None:
+            self.visual.send(f"{base}/voice_count", params.voice_count)
+            self.visual.send(f"{base}/cutoff", params.cutoff)
+            self.visual.send(f"{base}/lfo_rate", params.lfo_rate)
+            self.visual.send(f"{base}/reverb", params.reverb_mix)

pycodedj/sc/synths.scd

@@ -0,0 +1,151 @@
+// PyCodeDJ — SuperCollider synth definitions
+// Run this file in the SuperCollider IDE before using pycodedj eval.
+
+s.waitForBoot({
+    // Shared controls:
+    // cutoff = tone/brightness, lfoRate = pattern/modulation speed,
+    // reverbMix = space, gate = fade out when a loop is restarted/stopped.
+    SynthDef(\pycodedj_sub_bass, {
+        arg cutoff = 900, lfoRate = 1.0, reverbMix = 0.05, amp = 0.38, gate = 1;
+        var trig, freq, env, click, sig;
+        trig = Impulse.kr(lfoRate.clip(0.25, 4.0));
+        freq = Demand.kr(trig, 0, Dseq([36, 36, 43, 34, 36, 48, 43, 34].midicps, inf));
+        env = Decay2.kr(trig, 0.004, 0.32);
+        click = Decay2.kr(trig, 0.001, 0.018) * WhiteNoise.ar(0.08);
+        sig = (SinOsc.ar(freq) + (Saw.ar(freq * 0.5) * 0.28) + click) * env;
+        sig = RLPF.ar(sig.tanh, cutoff.clip(90, 1800), 0.28);
+        env = EnvGen.kr(Env.asr(0.1, 1, 0.2), gate, doneAction: 2);
+        sig = FreeVerb.ar(sig, reverbMix.clip(0, 0.8)) * env * amp;
+        Out.ar(0, sig ! 2);
+    }).add;
+
+    SynthDef(\pycodedj_hat_engine, {
+        arg cutoff = 6500, lfoRate = 1.5, reverbMix = 0.08, amp = 0.18, gate = 1;
+        var trig, openTrig, closedEnv, openEnv, tone, sig, env;
+        trig = Impulse.kr((lfoRate * 4).clip(3, 18));
+        openTrig = PulseDivider.kr(trig, 4);
+        closedEnv = Decay2.kr(trig, 0.001, 0.045);
+        openEnv = Decay2.kr(openTrig, 0.002, 0.18);
+        tone = cutoff.linlin(200, 4000, 5000, 14000).clip(5000, 14000);
+        sig = HPF.ar(WhiteNoise.ar, tone * 0.7);
+        sig = BPF.ar(sig, tone, 0.45) * (closedEnv + (openEnv * 0.75));
+        env = EnvGen.kr(Env.asr(0.01, 1, 0.08), gate, doneAction: 2);
+        sig = FreeVerb.ar(sig, reverbMix.clip(0, 0.45), 0.25, 0.15) * env * amp;
+        Out.ar(0, Pan2.ar(sig, SinOsc.kr(0.13).range(-0.25, 0.25)));
+    }).add;
+
+    SynthDef(\pycodedj_neon_stab, {
+        arg cutoff = 1200, lfoRate = 0.25, reverbMix = 0.25, amp = 0.22, gate = 1;
+        var trig, root, freqs, env, sig, gateEnv;
+        trig = Impulse.kr((lfoRate * 0.75).clip(0.08, 1.5));
+        root = Demand.kr(trig, 0, Dseq([48, 43, 46, 41], inf));
+        freqs = (root + [0, 3, 7, 10]).midicps;
+        env = Decay2.kr(trig, 0.01, 0.42);
+        sig = Splay.ar(VarSaw.ar(freqs * [1, 1.004, 0.997, 1.006], 0, 0.42)) * 0.2;
+        sig = RLPF.ar(sig, cutoff.clip(600, 4500), 0.32) * env;
+        gateEnv = EnvGen.kr(Env.asr(0.05, 1, 0.25), gate, doneAction: 2);
+        sig = FreeVerb.ar(sig, reverbMix.clip(0, 0.8), 0.55, 0.35) * gateEnv * amp;
+        Out.ar(0, sig);
+    }).add;
+
+    SynthDef(\pycodedj_acid_lead, {
+        arg cutoff = 2100, lfoRate = 2.0, reverbMix = 0.12, amp = 0.22, gate = 1;
+        var trig, note, freq, env, filterEnv, sig, gateEnv;
+        trig = Impulse.kr((lfoRate * 3).clip(2, 14));
+        note = Demand.kr(trig, 0, Dseq([48, 51, 55, 58, 60, 58, 55, 51], inf));
+        freq = Lag.kr(note.midicps, 0.045);
+        env = Decay2.kr(trig, 0.003, 0.16);
+        filterEnv = Decay2.kr(trig, 0.002, 0.12).range(0, 2600);
+        sig = (Pulse.ar(freq, 0.48) * 0.65) + (Saw.ar(freq * 2) * 0.18);
+        sig = RLPF.ar(sig, (cutoff + filterEnv).clip(500, 6200), 0.16).tanh * env;
+        gateEnv = EnvGen.kr(Env.asr(0.02, 1, 0.12), gate, doneAction: 2);
+        sig = FreeVerb.ar(sig, reverbMix.clip(0, 0.55), 0.35, 0.22) * gateEnv * amp;
+        Out.ar(0, Pan2.ar(sig, SinOsc.kr(0.21).range(-0.35, 0.35)));
+    }).add;
+
+    SynthDef(\pycodedj_warehouse_air, {
+        arg cutoff = 700, lfoRate = 0.1, reverbMix = 0.6, amp = 0.24, gate = 1;
+        var sweep, dust, tail, sig, env;
+        sweep = LFNoise1.kr(lfoRate.clip(0.03, 0.8)).range(0, 1).exprange(180, cutoff.clip(350, 3600));
+        dust = Decay2.kr(Dust.kr((lfoRate * 5).clip(0.5, 7)), 0.02, 1.2) * PinkNoise.ar(0.08);
+        tail = BPF.ar(PinkNoise.ar(0.22), sweep, 0.2);
+        sig = HPF.ar(tail + dust, 140);
+        sig = FreeVerb.ar(sig, reverbMix.clip(0.25, 0.9), 0.92, 0.65);
+        env = EnvGen.kr(Env.asr(1.5, 1, 2.0), gate, doneAction: 2);
+        Out.ar(0, Pan2.ar(sig * env * amp, LFNoise1.kr(0.08)));
+    }).add;
+
+    SynthDef(\pycodedj_base, {
+        arg cutoff = 800, lfoRate = 0.5, reverbMix = 0.2, amp = 0.3, gate = 1;
+        var sig, env, lfo;
+        lfo = SinOsc.kr(lfoRate, 0, 0.3, 1);
+        sig = Saw.ar(220 * lfo);
+        sig = RLPF.ar(sig, cutoff.clip(200, 4000), 0.5);
+        env = EnvGen.kr(Env.asr(0.1, 1, 0.2), gate, doneAction: 2);
+        sig = FreeVerb.ar(sig, reverbMix.clip(0, 0.8)) * env * amp;
+        Out.ar(0, sig ! 2);
+    }).add;
+
+    s.sync;
+
+    // Registry: loop name -> array of running Synth instances
+    ~loops = Dictionary.new;
+
+    ~synthForLoop = { |name|
+        switch (name,
+            "sub_bass", { \pycodedj_sub_bass },
+            "hat_engine", { \pycodedj_hat_engine },
+            "neon_stab", { \pycodedj_neon_stab },
+            "acid_lead", { \pycodedj_acid_lead },
+            "warehouse_air", { \pycodedj_warehouse_air },
+            { \pycodedj_base }
+        );
+    };
+
+    // Helper: start or restart a loop with given voice count
+    ~startLoop = { |name, voiceCount = 1|
+        var synthName, synths;
+        if (~loops[name].notNil) {
+            ~loops[name].do({ |synth| synth.set(\gate, 0) });
+        };
+        synthName = ~synthForLoop.value(name);
+        synths = voiceCount.collect({ Synth(synthName) });
+        ~loops[name] = synths;
+    };
+
+    // Single handler for all /pycodedj/loop/<name>/<param> addresses.
+    // OSCdef does not interpret "*" as a wildcard — it registers the path literally.
+    // OSCFunc with nil path receives every incoming OSC message and we filter by prefix.
+    // var は SC では実行文より前に宣言しなければならないため、
+    // すべての var をクロージャ先頭にまとめる。
+    OSCFunc({ |msg, time, addr|
+        var parts, name, param, val;
+        parts = msg[0].asString.split($/);
+        // parts: ["", "pycodedj", "loop", <name>, <param>]
+        if (parts.size != 5) { ^nil };
+        if (parts[1] != "pycodedj") { ^nil };
+        if (parts[2] != "loop") { ^nil };
+
+        name  = parts[3];
+        param = parts[4];
+        val   = msg[1];
+
+        switch (param,
+            "voice_count", {
+                if (val.asInteger <= 0) {
+                    if (~loops[name].notNil) {
+                        ~loops[name].do({ |synth| synth.set(\gate, 0) });
+                        ~loops[name] = nil;
+                    };
+                } {
+                    ~startLoop.value(name, val.asInteger);
+                };
+            },
+            "cutoff",    { ~loops[name].do({ |synth| synth.set(\cutoff,    val.asFloat) }) },
+            "lfo_rate",  { ~loops[name].do({ |synth| synth.set(\lfoRate,   val.asFloat) }) },
+            "reverb",    { ~loops[name].do({ |synth| synth.set(\reverbMix, val.asFloat) }) }
+        );
+    });  // nil path = receive all OSC messages
+
+    "PyCodeDJ synths loaded. Ready.".postln;
+});

pycodedj/watcher.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import os
+import threading
+from pathlib import Path
+from typing import Callable
+
+from .block_parser import parse_blocks
+from .engine import Engine
+from .osc_bridge import OscError
+
+
+class _LoopFileHandler:
+    """ファイル変更イベントを受け取り、デバウンス後に全ループを再評価する。"""
+
+    def __init__(
+        self,
+        path: str,
+        engine: Engine,
+        on_eval: Callable[[str, int], None] | None = None,
+        debounce: float = 0.3,
+    ) -> None:
+        self._path = os.path.abspath(path)
+        self._engine = engine
+        self._on_eval = on_eval
+        self._debounce = debounce
+        self._timer: threading.Timer | None = None
+        self._active_names: set[str] = set()
+
+    def dispatch(self, src_path: str) -> None:
+        """watchdog の on_modified から呼ぶ。対象ファイル以外は無視する。"""
+        if os.path.abspath(src_path) != self._path:
+            return
+        if self._timer is not None:
+            self._timer.cancel()
+        self._timer = threading.Timer(self._debounce, self._eval_all)
+        self._timer.start()
+
+    def _eval_all(self) -> None:
+        try:
+            source = Path(self._path).read_text(encoding="utf-8")
+        except OSError:
+            return
+        blocks = parse_blocks(source)
+        current_names = {b.name for b in blocks}
+
+        for name in self._active_names - current_names:
+            try:
+                self._engine.stop_loop(name)
+            except OscError:
+                pass
+        self._active_names = current_names
+
+        for block in blocks:
+            self._engine.eval_block(block)
+        if self._on_eval is not None:
+            self._on_eval(self._path, len(blocks))
+
+
+def watch(
+    path: str,
+    engine: Engine,
+    debounce: float = 0.3,
+    on_eval: Callable[[str, int], None] | None = None,
+) -> None:
+    """ファイルを監視し、変更のたびに全ループを再評価する。Ctrl+C で停止。
+
+    Args:
+        path: 監視するファイルのパス
+        engine: eval_block を呼び出す Engine インスタンス
+        debounce: 連続変更イベントをまとめる待機時間（秒）
+        on_eval: 再評価後に呼ばれるコールバック (file_path, loop_count)
+    """
+    try:
+        from watchdog.events import FileSystemEventHandler
+        from watchdog.observers import Observer
+    except ImportError:
+        raise ImportError(
+            "watchdog が必要です: pip install 'pycodedj[watch]'"
+        )
+
+    handler_wrapper = _LoopFileHandler(path, engine, on_eval=on_eval, debounce=debounce)
+
+    class _WatchdogAdapter(FileSystemEventHandler):
+        def on_modified(self, event: object) -> None:
+            src = getattr(event, "src_path", "")
+            handler_wrapper.dispatch(str(src))
+
+        # vim/emacs などのアトミックセーブは rename で完了するため on_moved も受ける
+        def on_moved(self, event: object) -> None:
+            src = getattr(event, "dest_path", "")
+            handler_wrapper.dispatch(str(src))
+
+        def on_created(self, event: object) -> None:
+            src = getattr(event, "src_path", "")
+            handler_wrapper.dispatch(str(src))
+
+    abs_path = os.path.abspath(path)
+    watch_dir = os.path.dirname(abs_path)
+
+    observer = Observer()
+    observer.schedule(_WatchdogAdapter(), watch_dir, recursive=False)
+    observer.start()
+    try:
+        observer.join()
+    except KeyboardInterrupt:
+        observer.stop()
+        observer.join()

pycodedj-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: pycodedj
+Version: 0.1.0
+Requires-Python: >=3.10
+Requires-Dist: python-osc>=1.8
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: watch
+Requires-Dist: watchdog>=3.0; extra == 'watch'

pycodedj-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pycodedj/__init__.py,sha256=o4oFElgbHHWqJWmyO2VYO2xkp3k2aMRRl1TIvA9Dkh0,109
+pycodedj/__main__.py,sha256=BPwKuza3CxiXeTfP1ScWOIyLma7psR3bpvh2IYdaML4,4018
+pycodedj/analyzer.py,sha256=ph2IJu-RrYWJ3De4CFKP6KHid_en2pO9siZZpo_m-Rg,1863
+pycodedj/block_parser.py,sha256=xFININqKVF9ZEoH4pIWWBllWr-qYKfCTla3TihW0yDg,1241
+pycodedj/engine.py,sha256=40bHkBvg5GqLSuamIQ2LB7IdV-hCu_BPD_DXga9yHwA,1228
+pycodedj/mapper.py,sha256=_9RS-mKyDP4WyNVVQRCcSrFUv77t6QO85lhmNP6Fec0,1102
+pycodedj/osc_bridge.py,sha256=cm89GExpl8oVeJlkDcfGM2rFfazCD28CYGGZjfSTnBk,1835
+pycodedj/watcher.py,sha256=v2AWaNGhe2Ek0dOEbYUkX8UO7m2Kg8cyIOuEzvZe-6I,3575
+pycodedj/examples/club_set.py,sha256=mFfD20V5f-EdAaqdaFQ-xWzasfACAx7U_IDu1GqXgZw,1730
+pycodedj/examples/demo.py,sha256=GXSGBWPKjM7PiwAFZ5w84GCAMco1ecFOwOd3TLhbJ14,468
+pycodedj/examples/hello_sc.py,sha256=PIISxg0b7z_5ajVvzNepIHG3pPaK4ENQSR-GA1QkphA,825
+pycodedj/sc/synths.scd,sha256=FsT8K2rzVHEdIN_GCeqhwTu44vxZ4KCll2_AnMBw7S4,6970
+pycodedj-0.1.0.dist-info/METADATA,sha256=yW_BPRRaFI21q5uH6jst2Kj2epGMcEcU40N1stm0N3E,306
+pycodedj-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pycodedj-0.1.0.dist-info/entry_points.txt,sha256=00gIRaOWEf9DfkET0UBiK7wrRP8EfLKY6czyPGfoydQ,52
+pycodedj-0.1.0.dist-info/RECORD,,

pycodedj-0.1.0.dist-info/WHEEL

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

pycodedj-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pycodedj = pycodedj.__main__:main