pycodedj 0.4.0__tar.gz → 0.5.0__tar.gz

{pycodedj-0.4.0 → pycodedj-0.5.0}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.5.0] - 2026-05-08
+
+### Features
+
+- `pattern()` にコード構文 `[0 3]` を追加。1 ステップで複数の度数を同時発音できる
+- `pattern()` にタイ構文 `~` を追加。直前の音（または コード）を次のステップまで延長できる
+
+### Improvements
+
+- OSC パターン payload を v2 フォーマット（`"v2"` マーカー付き flat encoding）に統一
+- SC 側 `~setupPattern` を v2 専用 decode に変更。`\sustain` を `Pseq` で制御し、chord/tie の発音長を正確に管理
+- `encode_steps()` を `pattern.py` に追加。Python 内部の `list[PatternStep]` を OSC flat encoding に変換する
+
+---
+
 ## [0.4.0] - 2026-05-08
 
 ### Features

{pycodedj-0.4.0 → pycodedj-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycodedj
-Version: 0.4.0
+Version: 0.5.0
 License: MIT License with Commons Clause
         
         "Commons Clause" License Condition v1.0
@@ -213,8 +213,24 @@ def kick():
 @loop("bass", synth="bass_acid", root="A1", scale="minor", dur=0.25)
 def bass():
     pattern("0 . 3 . 5 .")
+
+# Chords and ties
+@loop("chord", synth="note", root="A1", scale="minor", dur=0.25)
+def chord():
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # [0 3] = two-note chord, ~ = sustain the previous note one more step
 ```
 
+Token reference:
+
+| Token | Meaning |
+| :--- | :--- |
+| `x` | Trigger (plays root note) |
+| `.` | Rest (silence) |
+| `0`, `1`, `2` … | Scale degree (pitch) |
+| `[0 3]` | Chord (multiple degrees simultaneously) |
+| `~` | Tie (extends the previous note/chord by one step) |
+
 `@loop` arguments for pattern mode:
 
 | Argument | Description |

{pycodedj-0.4.0 → pycodedj-0.5.0}/README.ja.md

@@ -151,8 +151,24 @@ def kick():
 @loop("bass", synth="bass_acid", root="A1", scale="minor", dur=0.25)
 def bass():
     pattern("0 . 3 . 5 .")
+
+# コードとタイ
+@loop("chord", synth="note", root="A1", scale="minor", dur=0.25)
+def chord():
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # [0 3] = 2音コード、~ = 直前の音を伸ばす
 ```
 
+`pattern()` のトークン一覧:
+
+| トークン | 意味 |
+| :--- | :--- |
+| `x` | トリガー（ルート音で鳴らす） |
+| `.` | 休符 |
+| `0`, `1`, `2` … | スケール度数 |
+| `[0 3]` | コード（複数の度数を同時発音） |
+| `~` | タイ（直前の音を 1 ステップ延長） |
+
 `@loop` に渡す引数:
 
 | 引数 | 説明 |

{pycodedj-0.4.0 → pycodedj-0.5.0}/README.md

@@ -151,8 +151,24 @@ def kick():
 @loop("bass", synth="bass_acid", root="A1", scale="minor", dur=0.25)
 def bass():
     pattern("0 . 3 . 5 .")
+
+# Chords and ties
+@loop("chord", synth="note", root="A1", scale="minor", dur=0.25)
+def chord():
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # [0 3] = two-note chord, ~ = sustain the previous note one more step
 ```
 
+Token reference:
+
+| Token | Meaning |
+| :--- | :--- |
+| `x` | Trigger (plays root note) |
+| `.` | Rest (silence) |
+| `0`, `1`, `2` … | Scale degree (pitch) |
+| `[0 3]` | Chord (multiple degrees simultaneously) |
+| `~` | Tie (extends the previous note/chord by one step) |
+
 `@loop` arguments for pattern mode:
 
 | Argument | Description |

{pycodedj-0.4.0 → pycodedj-0.5.0}/docs/manual.html

@@ -801,6 +801,8 @@ def kick_drum():
             <tr><td><code>x</code></td><td>ここで音を鳴らす（トリガー）</td></tr>
             <tr><td><code>.</code></td><td>休符（無音）</td></tr>
             <tr><td><code>0</code>, <code>1</code>, <code>2</code> …</td><td>音を鳴らす + 音程（スケール度数）</td></tr>
+            <tr><td><code>[0 3]</code></td><td>コード（複数の度数を同時発音）</td></tr>
+            <tr><td><code>~</code></td><td>タイ（直前の音を 1 ステップ延長）</td></tr>
           </tbody>
         </table>
 
@@ -872,6 +874,28 @@ def melody():
           </tbody>
         </table>
 
+        <h3>コード — 複数の音を同時に鳴らす</h3>
+
+        <p>角括弧で複数の度数を囲むと、1 ステップで複数の音を同時に鳴らせます。</p>
+
+        <pre data-lang="python"><code id="code-s7-chord">@loop("chord", synth="note", root="C3", scale="minor", dur=0.5)
+def chord():
+    pattern("[0 2 4] . [0 3] .")
+    # [0 2 4]→C3+Eb3+G3（短三和音）, 休, [0 3]→C3+Eb3, 休</code></pre>
+
+        <p>コード内に書けるのは <strong>0 以上の整数のみ</strong>です。<code>.</code>・<code>x</code>・<code>~</code> は書けません。</p>
+
+        <h3>タイ — 音を伸ばす</h3>
+
+        <p><code>~</code> を使うと、直前の音（またはコード）を次のステップまで伸ばせます。</p>
+
+        <pre data-lang="python"><code id="code-s7-tie">@loop("bass", synth="note", root="A1", scale="minor", dur=0.25)
+def bass():
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # 0→A1, 休, [0 3]→和音（2ステップ持続）, 5→F2, 休, 3→D2, 休</code></pre>
+
+        <p><code>~</code> は単音・コードの直後にのみ書けます。先頭・<code>.</code> や <code>x</code> の直後は書けません。</p>
+
         <h3>実例: キック・ベース・メロディー</h3>
 
         <pre data-lang="python"><code id="code-s7-4">from pycodedj import loop, pattern
@@ -882,7 +906,8 @@ def kick():
 
 @loop("bass", synth="bass_acid", root="A1", scale="minor", dur=0.25)
 def bass():
-    pattern("0 . 0 . 3 . 5 .")
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # 0→A1, 休, [0 3]→和音（2ステップ持続）, 5→F2, 休, 3→D2, 休
 
 @loop("melody", synth="acid_lead", root="A3", scale="minor", dur=0.5)
 def melody():

{pycodedj-0.4.0 → pycodedj-0.5.0}/docs/manual.ja.md

@@ -496,6 +496,8 @@ def kick_drum():
 | `x` | ここで音を鳴らす（トリガー） |
 | `.` | 休符（無音） |
 | `0`, `1`, `2` … | 音を鳴らす + 音程（スケール度数） |
+| `[0 3]` | コード（複数の度数を同時に鳴らす） |
+| `~` | タイ（直前の音を次のステップまで伸ばす） |
 
 スペースで区切ると 1 ステップになります。`"x . x ."` なら 4 ステップのパターンです。
 
@@ -584,6 +586,32 @@ def bass():
     # 0→C3, 休, x→C3, 休, 3→Eb3, 休, x→C3, 休
 ```
 
+### コード — 複数の音を同時に鳴らす
+
+`[0 3]` のように角括弧で複数の度数を囲むと、1 ステップで複数の音を同時に鳴らせます。
+
+```python
+@loop("chord", synth="note", root="C3", scale="minor", dur=0.5)
+def chord():
+    pattern("[0 2 4] . [0 3] .")
+    # [0 2 4]→C3+Eb3+G3（短三和音）, 休, [0 3]→C3+Eb3, 休
+```
+
+コード内に書けるのは **0 以上の整数のみ** です。`.`・`x`・`~` は書けません。
+
+### タイ — 音を伸ばす
+
+`~` を使うと、直前の音（または コード）を次のステップまで伸ばせます。
+
+```python
+@loop("bass", synth="note", root="A1", scale="minor", dur=0.25)
+def bass():
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # 0→A1, 休, [0 3]→和音（2ステップ分 持続）, 5→F2, 休, 3→D2, 休
+```
+
+`~` は単音・コードの直後にのみ書けます。先頭・`.` や `x` の直後は書けません。
+
 ### ルートノートの書き方
 
 `root=` にはノート名 + オクターブ番号を渡します。
@@ -596,7 +624,7 @@ def bass():
 | `"F#3"` | F♯3（`s` を使って `"Fs3"` とも書ける） |
 | `"C1"` | 低い C |
 
-### 実例: キックとベースとメロディー
+### 実例: キックとベースとコード
 
 ```python
 from pycodedj import loop, pattern
@@ -607,7 +635,8 @@ def kick():
 
 @loop("bass", synth="bass_acid", root="A1", scale="minor", dur=0.25)
 def bass():
-    pattern("0 . 0 . 3 . 5 .")
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # 0→A1, 休, [0 3]→2音コード（2ステップ持続）, 5→F2, 休, 3→D2, 休
 
 @loop("melody", synth="acid_lead", root="A3", scale="minor", dur=0.5)
 def melody():

{pycodedj-0.4.0 → pycodedj-0.5.0}/docs/manual.md

@@ -477,6 +477,8 @@ The string passed to `pattern()` describes a sequence of steps:
 | `x` | Trigger: play the sound here |
 | `.` | Rest: silence |
 | `0`, `1`, `2` … | Play the sound at this scale degree |
+| `[0 3]` | Chord: play multiple degrees simultaneously |
+| `~` | Tie: extend the previous note or chord by one step |
 
 Tokens are separated by spaces. `"x . x ."` is a 4-step pattern.
 
@@ -563,6 +565,32 @@ def bass():
     # 0→C3, rest, x→C3, rest, 3→Eb3, rest, x→C3, rest
 ```
 
+### Chords — multiple notes at once
+
+Wrap multiple degrees in square brackets to play them simultaneously in one step:
+
+```python
+@loop("chord", synth="note", root="C3", scale="minor", dur=0.5)
+def chord():
+    pattern("[0 2 4] . [0 3] .")
+    # [0 2 4]→C3+Eb3+G3 (minor triad), rest, [0 3]→C3+Eb3, rest
+```
+
+Only non-negative integers are allowed inside brackets. `.`, `x`, and `~` are not valid inside a chord.
+
+### Ties — sustaining a note
+
+Use `~` to extend the previous note or chord by one additional step:
+
+```python
+@loop("bass", synth="note", root="A1", scale="minor", dur=0.25)
+def bass():
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # 0→A1, rest, [0 3] chord held for 2 steps, 5→F2, rest, 3→D2, rest
+```
+
+`~` can only follow a degree or chord. Placing it at the start, or after `.` or `x`, raises a `ValueError`.
+
 ### Root note notation
 
 | Notation | Note |
@@ -573,7 +601,7 @@ def bass():
 | `"F#3"` | F♯3 (also writable as `"Fs3"`) |
 | `"C1"` | Low C |
 
-### Full example: kick, bass, and melody
+### Full example: kick, bass, and chord
 
 ```python
 from pycodedj import loop, pattern
@@ -584,7 +612,8 @@ def kick():
 
 @loop("bass", synth="bass_acid", root="A1", scale="minor", dur=0.25)
 def bass():
-    pattern("0 . 0 . 3 . 5 .")
+    pattern("0 . [0 3] ~ 5 . 3 .")
+    # 0→A1, rest, [0 3] chord held for 2 steps, 5→F2, rest, 3→D2, rest
 
 @loop("melody", synth="acid_lead", root="A3", scale="minor", dur=0.5)
 def melody():

{pycodedj-0.4.0 → pycodedj-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pycodedj"
-version = "0.4.0"
+version = "0.5.0"
 requires-python = ">=3.10"
 readme = "README.md"
 license = {file = "LICENSE"}

{pycodedj-0.4.0 → pycodedj-0.5.0}/sc/synths.scd

@@ -697,47 +697,105 @@ s.waitForBoot({
         };
     };
 
-    ~setupPattern = { |name, rootMidi, scaleName, dur, synthName, steps|
-        var scale, pitches, instrSym;
+    ~setupPattern = { |name, rootMidi, scaleName, dur, synthName, version, encoded|
+        var scale, pitches, sustains, instrSym, i, hasDegree, decodeError, tieTargetIndex, degreeToMidi;
         scale = Scale.at(scaleName.asSymbol) ?? { Scale.chromatic };
-        pitches = steps.collect({ |step|
-            if (step == -2) {
-                Rest()
-            } {
-                if (step == -1) {
-                    rootMidi.asInteger
-                } {
-                    (scale.degrees[step % scale.size] + rootMidi + (step.div(scale.size) * 12)).asInteger
-                }
-            }
-        });
-        // Degree tokens require a freq-aware synth; trigger-only patterns can use the
-        // caller-specified synth= or fall back to the loop's default.
-        instrSym = if (steps.detect({ |s| s >= 0 }).notNil) {
-            \pycodedj_note
+        pitches = List.new;
+        sustains = List.new;
+        i = 0;
+        hasDegree = false;
+        decodeError = false;
+        tieTargetIndex = nil;
+        degreeToMidi = { |degree|
+            (scale.degrees[degree % scale.size] + rootMidi + (degree.div(scale.size) * 12)).asInteger
+        };
+        if (version.asString != "v2") {
+            ("PyCodeDJ pattern error: unsupported pattern payload version: " ++ version.asString).postln;
         } {
-            if (synthName.size > 0) {
-                ~synthForLoop.value(synthName)
-            } {
-                ~synthForLoop.value(name)
-            }
+            while ({ (i < encoded.size) and: { decodeError.not } }, {
+                var count = encoded[i].asInteger;
+                if (count == 0) {
+                    pitches.add(Rest());
+                    sustains.add(dur);
+                    tieTargetIndex = nil;
+                    i = i + 1;
+                } {
+                    if (count == -3) {
+                        if (tieTargetIndex.isNil) {
+                            "PyCodeDJ pattern error: tie must follow a note or chord.".postln;
+                            decodeError = true;
+                        } {
+                            sustains[tieTargetIndex] = sustains[tieTargetIndex] + dur;
+                            pitches.add(Rest());
+                            sustains.add(dur);
+                            i = i + 1;
+                        };
+                    } {
+                        if ((i + count) >= encoded.size) {
+                            "PyCodeDJ pattern error: truncated v2 pattern payload.".postln;
+                            decodeError = true;
+                        } {
+                            if (count == 1) {
+                                var degree = encoded[i + 1].asInteger;
+                                if (degree == -1) {
+                                    pitches.add(rootMidi.asInteger);
+                                    tieTargetIndex = nil;
+                                } {
+                                    pitches.add(degreeToMidi.value(degree));
+                                    hasDegree = true;
+                                    tieTargetIndex = sustains.size;
+                                };
+                                sustains.add(dur);
+                                i = i + 2;
+                            } {
+                                if (count > 1) {
+                                    pitches.add(Array.fill(count, { |j|
+                                        degreeToMidi.value(encoded[i + 1 + j].asInteger)
+                                    }));
+                                    sustains.add(dur);
+                                    hasDegree = true;
+                                    tieTargetIndex = sustains.size - 1;
+                                    i = i + 1 + count;
+                                } {
+                                    ("PyCodeDJ pattern error: invalid v2 pattern count: " ++ count).postln;
+                                    decodeError = true;
+                                };
+                            };
+                        };
+                    };
+                };
+            });
+            if (decodeError.not) {
+                // Degree and chord tokens require a freq-aware synth; trigger-only patterns can use the
+                // caller-specified synth= or fall back to the loop's default.
+                instrSym = if (hasDegree) {
+                    \pycodedj_note
+                } {
+                    if (synthName.size > 0) {
+                        ~synthForLoop.value(synthName)
+                    } {
+                        ~synthForLoop.value(name)
+                    }
+                };
+                Pdef(name.asSymbol,
+                    Pbind(
+                        \instrument, instrSym,
+                        \midinote, Pseq(pitches.asArray, inf),
+                        \dur, dur,
+                        \sustain, Pseq(sustains.asArray, inf),
+                        \amp,       Pfunc({ (~loopParams[name] ?? { (amp: 0.3) })[\amp] }),
+                        \cutoff,    Pfunc({ (~loopParams[name] ?? { (cutoff: 800) })[\cutoff] }),
+                        \lfoRate,   Pfunc({ (~loopParams[name] ?? { (lfoRate: 0.5) })[\lfoRate] }),
+                        \reverbMix, Pfunc({ (~loopParams[name] ?? { (reverbMix: 0.2) })[\reverbMix] }),
+                        \eqLow,     Pfunc({ (~loopParams[name] ?? { (low: 1) })[\low] }),
+                        \eqMid,     Pfunc({ (~loopParams[name] ?? { (mid: 1) })[\mid] }),
+                        \eqHigh,    Pfunc({ (~loopParams[name] ?? { (high: 1) })[\high] }),
+                    )
+                ).play(TempoClock.default);
+                ~patterns[name] = true;
+                ("PyCodeDJ pattern started: " ++ name).postln;
+            };
         };
-        Pdef(name.asSymbol,
-            Pbind(
-                \instrument, instrSym,
-                \midinote, Pseq(pitches, inf),
-                \dur, dur,
-                \amp,       Pfunc({ (~loopParams[name] ?? { (amp: 0.3) })[\amp] }),
-                \cutoff,    Pfunc({ (~loopParams[name] ?? { (cutoff: 800) })[\cutoff] }),
-                \lfoRate,   Pfunc({ (~loopParams[name] ?? { (lfoRate: 0.5) })[\lfoRate] }),
-                \reverbMix, Pfunc({ (~loopParams[name] ?? { (reverbMix: 0.2) })[\reverbMix] }),
-                \eqLow,     Pfunc({ (~loopParams[name] ?? { (low: 1) })[\low] }),
-                \eqMid,     Pfunc({ (~loopParams[name] ?? { (mid: 1) })[\mid] }),
-                \eqHigh,    Pfunc({ (~loopParams[name] ?? { (high: 1) })[\high] }),
-            )
-        ).play(TempoClock.default);
-        ~patterns[name] = true;
-        ("PyCodeDJ pattern started: " ++ name).postln;
     };
 
     // Single handler for all /pycodedj/loop/<name>/<param> addresses.
@@ -813,15 +871,16 @@ s.waitForBoot({
                     };
                 },
                 "pattern",   {
-                    // msg: [addr, rootMidi, scaleName, dur, synthName, step...]
-                    if (msg.size >= 5) {
+                    // msg: [addr, rootMidi, scaleName, dur, synthName, "v2", encoded...]
+                    if (msg.size >= 6) {
                         ~setupPattern.value(
                             name,
                             msg[1].asInteger,
                             msg[2].asString,
                             msg[3].asFloat,
                             msg[4].asString,
-                            msg[5..]
+                            msg[5].asString,
+                            msg[6..]
                         );
                     };
                 },

{pycodedj-0.4.0 → pycodedj-0.5.0}/src/pycodedj/__init__.py

@@ -2,5 +2,5 @@
 
 from ._loop import loop, pattern
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 __all__ = ["loop", "pattern"]

{pycodedj-0.4.0 → pycodedj-0.5.0}/src/pycodedj/engine.py

@@ -8,6 +8,7 @@ from .analyzer import analyze
 from .block_parser import LoopBlock
 from .mapper import MusicParams, map_features
 from .osc_bridge import OscBridge, OscError
+from .pattern import PatternStep
 
 
 @dataclass
@@ -76,7 +77,7 @@ class Engine:
 
     def _make_pattern_args(
         self, block: LoopBlock
-    ) -> tuple[int, str, float, list[int], str]:
+    ) -> tuple[int, str, float, list[PatternStep], str]:
         from .pattern import parse_pattern, root_to_midi
         steps = parse_pattern(block.pattern_str or "")
         midi = root_to_midi(block.root or "C4")

{pycodedj-0.4.0 → pycodedj-0.5.0}/src/pycodedj/osc_bridge.py

@@ -5,6 +5,8 @@ from typing import TYPE_CHECKING
 
 from pythonosc import udp_client
 
+from .pattern import PatternStep, encode_steps
+
 if TYPE_CHECKING:
     from .mapper import MusicParams
 
@@ -48,7 +50,7 @@ class OscBridge:
         root_midi: int,
         scale: str,
         dur: float,
-        steps: list[int],
+        steps: list[PatternStep],
         synth: str = "",
     ) -> None:
         self.audio.send(
@@ -57,7 +59,8 @@ class OscBridge:
             scale,
             dur,
             synth,
-            *steps,
+            "v2",
+            *encode_steps(steps),
         )
 
     def send_synth(self, name: str, synth: str) -> None:

pycodedj-0.5.0/src/pycodedj/pattern.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+# Pattern sentinel values:
+# REST means a silent step, TIE extends the previous degree/chord, TRIGGER fires
+# the loop/root synth without a scale degree.
+REST = -2
+TIE = -3
+TRIGGER = -1
+PatternStep = int | list[int]
+
+_NOTE_MAP = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
+_ACCIDENTAL = {"#": 1, "s": 1, "b": -1}
+
+
+def _tokenize_pattern(pattern_str: str) -> list[str]:
+    tokens: list[str] = []
+    i = 0
+    while i < len(pattern_str):
+        char = pattern_str[i]
+        if char.isspace():
+            i += 1
+            continue
+        if char == "[":
+            end = pattern_str.find("]", i + 1)
+            if end == -1:
+                raise ValueError("unterminated chord")
+            tokens.append(pattern_str[i : end + 1])
+            i = end + 1
+            continue
+        if char == "]":
+            raise ValueError("unexpected chord close")
+        start = i
+        while i < len(pattern_str) and not pattern_str[i].isspace():
+            if pattern_str[i] in "[]":
+                break
+            i += 1
+        tokens.append(pattern_str[start:i])
+    return tokens
+
+
+def _parse_degree(token: str) -> int:
+    if token.lstrip("-").isdigit():
+        degree = int(token)
+        if degree < 0:
+            raise ValueError(f"negative degree not allowed: {token!r}")
+        return degree
+    raise ValueError(f"unknown pattern token: {token!r}")
+
+
+def _parse_chord(token: str) -> list[int]:
+    body = token[1:-1].strip()
+    if not body:
+        raise ValueError("empty chord not allowed")
+    chord: list[int] = []
+    for part in body.split():
+        if part in {".", "x", "~"}:
+            raise ValueError(f"invalid chord token: {part!r}")
+        if not part.lstrip("-").isdigit():
+            raise ValueError(f"invalid chord token: {part!r}")
+        degree = int(part)
+        if degree < 0:
+            raise ValueError(f"negative degree not allowed in chord: {part!r}")
+        chord.append(degree)
+    return chord
+
+
+def parse_pattern(pattern_str: str) -> list[PatternStep]:
+    """
+    "x . x ."  -> [-1, -2, -1, -2]
+    "0 . 3 ."  -> [0, -2, 3, -2]
+    "0 . [0 3] ~" -> [0, -2, [0, 3], -3]
+    """
+    steps: list[PatternStep] = []
+    for token in _tokenize_pattern(pattern_str):
+        if token == ".":
+            steps.append(REST)
+        elif token == "x":
+            steps.append(TRIGGER)
+        elif token == "~":
+            if not steps or not (
+                isinstance(steps[-1], list) or steps[-1] not in {REST, TRIGGER, TIE}
+            ):
+                raise ValueError("tie must follow a degree or chord")
+            steps.append(TIE)
+        elif token.startswith("[") and token.endswith("]"):
+            steps.append(_parse_chord(token))
+        else:
+            steps.append(_parse_degree(token))
+    return steps
+
+
+def encode_steps(steps: list[PatternStep]) -> list[int | float | str]:
+    encoded: list[int | float | str] = []
+    for step in steps:
+        if isinstance(step, list):
+            encoded.append(len(step))
+            encoded.extend(step)
+        elif step == REST:
+            encoded.append(0)
+        elif step == TIE:
+            encoded.append(TIE)
+        else:
+            encoded.extend((1, step))
+    return encoded
+
+
+def root_to_midi(root: str) -> int:
+    """
+    "C3" -> 48, "A1" -> 33, "Bb2" -> 46
+    Convention: C-1=0, C0=12, C4=60 (General MIDI)
+    """
+    if not root or root[0] not in _NOTE_MAP:
+        raise ValueError(f"invalid root: {root!r}")
+    note = _NOTE_MAP[root[0]]
+    pos = 1
+    if pos < len(root) and root[pos] in _ACCIDENTAL:
+        note += _ACCIDENTAL[root[pos]]
+        pos += 1
+    octave_str = root[pos:]
+    if not octave_str or not (octave_str.lstrip("-").isdigit()):
+        raise ValueError(f"invalid root: {root!r}")
+    octave = int(octave_str)
+    return (octave + 1) * 12 + note

{pycodedj-0.4.0 → pycodedj-0.5.0}/tests/test_engine.py

@@ -386,7 +386,39 @@ def test_eval_block_pattern_values_correct() -> None:
     assert values[1] == "minor"
     assert values[2] == 0.25
     assert values[3] == "kick_pulse"
-    assert values[4:] == [-1, -2, -1, -2]
+    assert values[4:] == ["v2", 1, -1, 0, 1, -1, 0]
+
+
+def test_eval_block_pattern_chord_and_tie_values_correct() -> None:
+    engine = _make_engine()
+    from typing import cast
+    mock_send = cast(MagicMock, engine.bridge.audio._client).send_message
+    mock_send.reset_mock()
+
+    engine.eval_block(_pattern_block(pattern_str="0 . [0 3] ~ 5 . 3 .", root="C4", scale="minor", dur=0.25))
+
+    call_map = {c.args[0]: c.args[1] for c in mock_send.call_args_list}
+    values = call_map["/pycodedj/loop/kick/pattern"]
+    assert values == [
+        60,
+        "minor",
+        0.25,
+        "kick_pulse",
+        "v2",
+        1,
+        0,
+        0,
+        2,
+        0,
+        3,
+        -3,
+        1,
+        5,
+        0,
+        1,
+        3,
+        0,
+    ]
 
 
 def test_eval_block_pattern_uses_defaults_for_missing_root_scale_dur() -> None:

{pycodedj-0.4.0 → pycodedj-0.5.0}/tests/test_osc_bridge.py

@@ -5,6 +5,7 @@ import pytest
 
 from pycodedj.mapper import MusicParams
 from pycodedj.osc_bridge import OscBridge, OscEndpoint, OscError
+from pycodedj.pattern import REST, TIE, TRIGGER
 
 
 def _make_mock_endpoint(port: int) -> OscEndpoint:
@@ -133,11 +134,23 @@ def test_send_pattern_address(mock_endpoint: OscEndpoint) -> None:
 
 def test_send_pattern_values(mock_endpoint: OscEndpoint) -> None:
     bridge = OscBridge(audio=mock_endpoint)
-    bridge.send_pattern("kick", 48, "chromatic", 0.25, [-1, -2, -1, -2])
+    bridge.send_pattern("kick", 48, "chromatic", 0.25, [TRIGGER, REST, TRIGGER, REST])
 
     call_map = {c.args[0]: c.args[1] for c in _send_mock(mock_endpoint).call_args_list}
-    # order: root_midi, scale, dur, synth(""), steps...
-    assert call_map["/pycodedj/loop/kick/pattern"] == [48, "chromatic", 0.25, "", -1, -2, -1, -2]
+    # order: root_midi, scale, dur, synth(""), version, encoded steps...
+    assert call_map["/pycodedj/loop/kick/pattern"] == [
+        48,
+        "chromatic",
+        0.25,
+        "",
+        "v2",
+        1,
+        TRIGGER,
+        0,
+        1,
+        TRIGGER,
+        0,
+    ]
 
 
 def test_send_pattern_with_synth(mock_endpoint: OscEndpoint) -> None:
@@ -145,7 +158,7 @@ def test_send_pattern_with_synth(mock_endpoint: OscEndpoint) -> None:
     bridge.send_pattern("bass", 33, "minor", 0.5, [0, -2], synth="bass_acid")
 
     call_map = {c.args[0]: c.args[1] for c in _send_mock(mock_endpoint).call_args_list}
-    assert call_map["/pycodedj/loop/bass/pattern"] == [33, "minor", 0.5, "bass_acid", 0, -2]
+    assert call_map["/pycodedj/loop/bass/pattern"] == [33, "minor", 0.5, "bass_acid", "v2", 1, 0, 0]
 
 
 def test_send_pattern_empty_steps(mock_endpoint: OscEndpoint) -> None:
@@ -153,7 +166,34 @@ def test_send_pattern_empty_steps(mock_endpoint: OscEndpoint) -> None:
     bridge.send_pattern("bass", 33, "minor", 0.5, [])
 
     call_map = {c.args[0]: c.args[1] for c in _send_mock(mock_endpoint).call_args_list}
-    assert call_map["/pycodedj/loop/bass/pattern"] == [33, "minor", 0.5, ""]
+    assert call_map["/pycodedj/loop/bass/pattern"] == [33, "minor", 0.5, "", "v2"]
+
+
+def test_send_pattern_chord_and_tie_payload(mock_endpoint: OscEndpoint) -> None:
+    bridge = OscBridge(audio=mock_endpoint)
+    bridge.send_pattern("lead", 60, "minor", 0.25, [0, REST, [0, 3], TIE, 5, REST, 3, REST])
+
+    call_map = {c.args[0]: c.args[1] for c in _send_mock(mock_endpoint).call_args_list}
+    assert call_map["/pycodedj/loop/lead/pattern"] == [
+        60,
+        "minor",
+        0.25,
+        "",
+        "v2",
+        1,
+        0,
+        0,
+        2,
+        0,
+        3,
+        TIE,
+        1,
+        5,
+        0,
+        1,
+        3,
+        0,
+    ]
 
 
 def test_send_pattern_stop(mock_endpoint: OscEndpoint) -> None:

{pycodedj-0.4.0 → pycodedj-0.5.0}/tests/test_pattern.py

@@ -1,6 +1,6 @@
 import pytest
 
-from pycodedj.pattern import REST, TRIGGER, parse_pattern, root_to_midi
+from pycodedj.pattern import REST, TIE, TRIGGER, encode_steps, parse_pattern, root_to_midi
 
 
 # --- parse_pattern ---
@@ -34,6 +34,22 @@ def test_degree_pattern() -> None:
     assert parse_pattern("0 . 3 .") == [0, REST, 3, REST]
 
 
+def test_chord_pattern() -> None:
+    assert parse_pattern("[0 3]") == [[0, 3]]
+
+
+def test_chord_mixed_pattern() -> None:
+    assert parse_pattern("0 . [0 3] ~ 5 . 3 .") == [0, REST, [0, 3], TIE, 5, REST, 3, REST]
+
+
+def test_tie_after_degree() -> None:
+    assert parse_pattern("0 ~") == [0, TIE]
+
+
+def test_tie_after_chord() -> None:
+    assert parse_pattern("[0 3] ~") == [[0, 3], TIE]
+
+
 def test_longer_pattern() -> None:
     result = parse_pattern("x x . x . . x .")
     assert result == [TRIGGER, TRIGGER, REST, TRIGGER, REST, REST, TRIGGER, REST]
@@ -51,11 +67,46 @@ def test_trigger_constant_value() -> None:
     assert TRIGGER == -1
 
 
+def test_tie_constant_value() -> None:
+    assert TIE == -3
+
+
 def test_unknown_token_raises() -> None:
     with pytest.raises(ValueError, match="unknown pattern token"):
         parse_pattern("x y .")
 
 
+def test_leading_tie_raises() -> None:
+    with pytest.raises(ValueError, match="tie must follow"):
+        parse_pattern("~")
+
+
+def test_rest_then_tie_raises() -> None:
+    with pytest.raises(ValueError, match="tie must follow"):
+        parse_pattern(". ~")
+
+
+def test_trigger_then_tie_raises() -> None:
+    with pytest.raises(ValueError, match="tie must follow"):
+        parse_pattern("x ~")
+
+
+def test_empty_chord_raises() -> None:
+    with pytest.raises(ValueError, match="empty chord"):
+        parse_pattern("[]")
+
+
+@pytest.mark.parametrize("token", ["x", ".", "~"])
+def test_chord_special_token_raises(token: str) -> None:
+    with pytest.raises(ValueError, match="invalid chord token"):
+        parse_pattern(f"[0 {token}]")
+
+
+def test_chord_negative_degree_raises() -> None:
+    with pytest.raises(ValueError, match="negative degree not allowed in chord"):
+        parse_pattern("[0 -3]")
+
+
 def test_empty_string_returns_empty() -> None:
     assert parse_pattern("") == []
 
@@ -64,6 +115,33 @@ def test_whitespace_only_returns_empty() -> None:
     assert parse_pattern("   ") == []
 
 
+# --- encode_steps ---
+
+def test_encode_steps_rest() -> None:
+    assert encode_steps([REST]) == [0]
+
+
+def test_encode_steps_tie() -> None:
+    assert encode_steps([TIE]) == [TIE]
+
+
+def test_encode_steps_trigger() -> None:
+    assert encode_steps([TRIGGER]) == [1, TRIGGER]
+
+
+def test_encode_steps_note() -> None:
+    assert encode_steps([3]) == [1, 3]
+
+
+def test_encode_steps_chord() -> None:
+    assert encode_steps([[0, 3]]) == [2, 0, 3]
+
+
+def test_encode_steps_acceptance_pattern() -> None:
+    steps = parse_pattern("0 . [0 3] ~ 5 . 3 .")
+    assert encode_steps(steps) == [1, 0, 0, 2, 0, 3, TIE, 1, 5, 0, 1, 3, 0]
+
+
 # --- root_to_midi ---
 
 def test_c4() -> None:

pycodedj-0.4.0/src/pycodedj/pattern.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-REST = -2
-TRIGGER = -1
-
-_NOTE_MAP = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
-_ACCIDENTAL = {"#": 1, "s": 1, "b": -1}
-
-
-def parse_pattern(pattern_str: str) -> list[int]:
-    """
-    "x . x ."  -> [-1, -2, -1, -2]
-    "0 . 3 ."  -> [0, -2, 3, -2]
-    """
-    steps: list[int] = []
-    for token in pattern_str.split():
-        if token == ".":
-            steps.append(REST)
-        elif token == "x":
-            steps.append(TRIGGER)
-        elif token.lstrip("-").isdigit():
-            val = int(token)
-            if val < 0:
-                raise ValueError(f"negative degree not allowed: {token!r}")
-            steps.append(val)
-        else:
-            raise ValueError(f"unknown pattern token: {token!r}")
-    return steps
-
-
-def root_to_midi(root: str) -> int:
-    """
-    "C3" -> 48, "A1" -> 33, "Bb2" -> 46
-    Convention: C-1=0, C0=12, C4=60 (General MIDI)
-    """
-    if not root or root[0] not in _NOTE_MAP:
-        raise ValueError(f"invalid root: {root!r}")
-    note = _NOTE_MAP[root[0]]
-    pos = 1
-    if pos < len(root) and root[pos] in _ACCIDENTAL:
-        note += _ACCIDENTAL[root[pos]]
-        pos += 1
-    octave_str = root[pos:]
-    if not octave_str or not (octave_str.lstrip("-").isdigit()):
-        raise ValueError(f"invalid root: {root!r}")
-    octave = int(octave_str)
-    return (octave + 1) * 12 + note