shipwright-audio 0.1.0__py3-none-any.whl

shipwright/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.1.0"
+
+from .registry import sound, Buffer, Note, Instrument, Track, RenderSpec, names, get
+from . import dsp, instruments, compose

shipwright/cli.py

@@ -0,0 +1,132 @@
+"""The harness, as a console command. The whole point: edit a file in
+sounds/, run this, listen.
+
+    shipwright                 list all sounds
+    shipwright sea_bed         render one -> output/sea_bed.wav
+    shipwright all             render everything
+    shipwright sea_bed --ogg   also write a Vorbis .ogg
+    shipwright --watch sea_bed re-render on every save (tight loop)
+
+Sounds are loaded from ./sounds and written to ./output relative to the
+current directory (override with SHIPWRIGHT_ROOT / SHIPWRIGHT_SOUNDS /
+SHIPWRIGHT_OUTPUT).
+"""
+import argparse
+import importlib.util
+from pathlib import Path
+import time
+
+from . import __version__, config
+from .registry import Buffer, RenderSpec, clear, get, names
+
+
+def load_sounds():
+    if not config.SOUNDS_DIR.is_dir():
+        raise SystemExit(
+            f"no sounds directory at {config.SOUNDS_DIR}\n"
+            "cd into a project with a sounds/ folder, or set SHIPWRIGHT_SOUNDS."
+        )
+    clear()
+    for f in sorted(config.SOUNDS_DIR.glob("*.py")):
+        spec = importlib.util.spec_from_file_location(f.stem, f)
+        if spec is None or spec.loader is None:
+            raise SystemExit(f"could not load sound file: {f}")
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+
+
+def _available():
+    sound_names = names()
+    return ", ".join(sound_names) if sound_names else "(none)"
+
+
+def _output_path(name):
+    config.OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    return config.OUTPUT_DIR / f"{name}.wav"
+
+
+def _display_path(path):
+    try:
+        return path.relative_to(Path.cwd())
+    except ValueError:
+        return path
+
+
+def render_one(name, ogg=False):
+    if name not in names():
+        raise SystemExit(f"unknown sound '{name}'. Available sounds: {_available()}")
+
+    obj = get(name)()
+    if isinstance(obj, Buffer):
+        from .engine import render_buffer
+        audio = render_buffer(obj)
+        sample_rate = obj.sr
+    elif isinstance(obj, RenderSpec):
+        from .engine import render_spec
+        audio = render_spec(obj)
+        sample_rate = config.SR
+    else:
+        raise SystemExit(
+            f"sound '{name}' returned {type(obj).__name__}; expected Buffer or RenderSpec."
+        )
+
+    import soundfile as sf
+
+    out = _output_path(name)
+    sf.write(out, audio, sample_rate)
+    if ogg:
+        sf.write(out.with_suffix(".ogg"), audio, sample_rate, format="OGG", subtype="VORBIS")
+    dur = len(audio) / sample_rate
+    print(f"  {name:14s} -> {_display_path(out)}   {dur:4.1f}s  peak {abs(audio).max():.2f}")
+
+
+def build_parser():
+    p = argparse.ArgumentParser(
+        prog="shipwright",
+        description="Render sounds defined in ./sounds to ./output.",
+    )
+    p.add_argument("target", nargs="?",
+                   help="sound name to render, or 'all'. Omit to list sounds.")
+    p.add_argument("--ogg", action="store_true",
+                   help="also write a Vorbis .ogg next to the .wav")
+    p.add_argument("--watch", action="store_true",
+                   help="re-render TARGET on every save (Ctrl-C to stop)")
+    p.add_argument("--version", action="version",
+                   version=f"%(prog)s {__version__}")
+    return p
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+
+    if args.watch:
+        if not args.target:
+            raise SystemExit("--watch needs a sound name, e.g. shipwright --watch sea_bed")
+        load_sounds()
+        print(f"watching {config.SOUNDS_DIR} — rendering '{args.target}' on save (Ctrl-C to stop)")
+        last = 0
+        while True:
+            m = max((f.stat().st_mtime for f in config.SOUNDS_DIR.glob("*.py")), default=0)
+            if m != last:
+                last = m
+                try:
+                    load_sounds()
+                    render_one(args.target, args.ogg)
+                except Exception as e:
+                    print("  error:", e)
+            time.sleep(0.4)
+
+    load_sounds()
+    if not args.target:
+        print("sounds:", _available())
+        return
+    targets = names() if args.target == "all" else [args.target]
+    if args.target != "all" and args.target not in names():
+        raise SystemExit(f"unknown sound '{args.target}'. Available sounds: {_available()}")
+    print(f"rendering {len(targets)} sound(s) @ {config.SR} Hz")
+    for t0 in targets:
+        render_one(t0, args.ogg)
+
+
+if __name__ == "__main__":
+    main()

shipwright/compose.py

@@ -0,0 +1,48 @@
+"""The composition layer (above the engine). Tiny helpers to turn chord
+symbols / pitch lists into Note objects. Swap this for music21 if you want
+richer theory; the engine only cares about the Note list."""
+from .registry import Note
+
+_NOTE = {'C':0,'C#':1,'Db':1,'D':2,'D#':3,'Eb':3,'E':4,'F':5,'F#':6,'Gb':6,
+         'G':7,'G#':8,'Ab':8,'A':9,'A#':10,'Bb':10,'B':11}
+_QUAL = {'':[0,4,7],'m':[0,3,7],'7':[0,4,7,10],'m7':[0,3,7,10],
+         'maj7':[0,4,7,11],'sus2':[0,2,7],'sus4':[0,5,7]}
+
+def note_to_midi(name, octave=4):
+    return 12 * (octave + 1) + _NOTE[name]
+
+def _split(sym):
+    if len(sym) > 1 and sym[1] in '#b':
+        return sym[:2], sym[2:]
+    return sym[:1], sym[1:]
+
+def parse_chord(sym, octave=3):
+    root, qual = _split(sym)
+    base = note_to_midi(root, octave)
+    return [base + iv for iv in _QUAL.get(qual, [0, 4, 7])]
+
+def progression(chords, bpm=70, beats_per_chord=4, repeats=1, octave=3, vel=70):
+    spb = 60.0 / bpm; notes = []; cur = 0.0
+    for _ in range(repeats):
+        for c in chords:
+            for p in parse_chord(c, octave):
+                notes.append(Note(p, cur, beats_per_chord * spb, vel))
+            cur += beats_per_chord * spb
+    return notes
+
+def melody(pitches, bpm=70, note_beats=None, start_beat=0.0, vel=90):
+    spb = 60.0 / bpm; cur = start_beat * spb; notes = []
+    nb = note_beats or [1] * len(pitches)
+    for p, b in zip(pitches, nb):
+        if p is not None:
+            notes.append(Note(p, cur, b * spb * 0.95, vel))
+        cur += b * spb
+    return notes
+
+def bassline(roots, bpm=70, octave=2, beats_per_note=4, repeats=1, vel=80):
+    spb = 60.0 / bpm; notes = []; cur = 0.0
+    for _ in range(repeats):
+        for r in roots:
+            notes.append(Note(note_to_midi(r, octave), cur, beats_per_note * spb * 0.9, vel))
+            cur += beats_per_note * spb
+    return notes

shipwright/config.py

@@ -0,0 +1,22 @@
+"""Global settings + paths. One place to change sample rate / output dir.
+
+Data dirs are anchored to the current working directory so the installed
+command works in whatever project you run it from. Override any of them
+with environment variables (SHIPWRIGHT_ROOT / _SOUNDS / _OUTPUT / _SOUNDFONTS).
+"""
+import os
+from pathlib import Path
+
+SR = 44100          # sample rate for everything
+BLOCK = 512         # DawDreamer render block size
+MASTER_CEILING = 0.97  # peak limit so renders never clip the file
+
+
+def _dir(env, default):
+    return Path(os.environ[env]).expanduser() if env in os.environ else default
+
+
+ROOT = _dir("SHIPWRIGHT_ROOT", Path.cwd())
+SOUNDS_DIR = _dir("SHIPWRIGHT_SOUNDS", ROOT / "sounds")
+SOUNDFONT_DIR = _dir("SHIPWRIGHT_SOUNDFONTS", ROOT / "soundfonts")
+OUTPUT_DIR = _dir("SHIPWRIGHT_OUTPUT", ROOT / "output")

shipwright/dsp.py

@@ -0,0 +1,70 @@
+"""numpy synthesis primitives for SFX. Pure code -> samples. Deterministic,
+tiny, no black box. Build blips, creaks, whooshes from oscillators + noise
++ envelopes + filters."""
+import numpy as np
+from scipy.signal import butter, sosfilt
+from .config import SR
+
+def t(dur):
+    return np.linspace(0, dur, int(SR * dur), endpoint=False)
+
+# --- oscillators -----------------------------------------------------------
+def sine(freq, dur, amp=1.0, phase=0.0):
+    return amp * np.sin(2 * np.pi * freq * t(dur) + phase)
+
+def saw(freq, dur, amp=1.0):
+    x = t(dur)
+    return amp * (2 * ((freq * x) % 1.0) - 1.0)
+
+def square(freq, dur, amp=1.0, duty=0.5):
+    return amp * np.where((freq * t(dur)) % 1.0 < duty, 1.0, -1.0)
+
+def noise(dur, amp=1.0, seed=None):
+    rng = np.random.default_rng(seed)
+    return amp * rng.uniform(-1, 1, int(SR * dur))
+
+# --- envelopes -------------------------------------------------------------
+def ad_env(sig, attack=0.005, release=0.1):
+    """Apply a linear attack/release to an existing signal."""
+    n = len(sig); env = np.ones(n)
+    a, r = int(attack * SR), int(release * SR)
+    if a: env[:a] = np.linspace(0, 1, a)
+    if r: env[-r:] *= np.linspace(1, 0, r)
+    return sig * env
+
+def perc_env(dur, decay=0.99):
+    """Exponential percussive decay over `dur` seconds."""
+    n = int(SR * dur)
+    return decay ** np.arange(n) if 0 < decay < 1 else np.exp(-np.linspace(0, 6, n))
+
+# --- filters (scipy biquads) ----------------------------------------------
+def _sos(kind, cutoff, order=2):
+    nyq = SR / 2
+    if kind == 'band':
+        wn = [float(np.clip(c / nyq, 1e-4, 0.999)) for c in cutoff]
+    else:
+        wn = float(np.clip(cutoff / nyq, 1e-4, 0.999))
+    return butter(order, wn, btype=kind, output='sos')
+
+def lowpass(sig, cutoff, order=2):  return sosfilt(_sos('low', cutoff, order=order), sig)
+def highpass(sig, cutoff, order=2): return sosfilt(_sos('high', cutoff, order=order), sig)
+def bandpass(sig, low, high, order=2):
+    return sosfilt(_sos('band', [low, high], order=order), sig)
+
+# --- utilities -------------------------------------------------------------
+def layer(*sigs):
+    """Sum signals of any length (zero-padded to the longest)."""
+    n = max(len(s) for s in sigs)
+    out = np.zeros(n)
+    for s in sigs:
+        out[:len(s)] += s
+    return out
+
+def to_stereo(sig, pan=0.0):
+    """Mono -> stereo with equal-power pan (-1 left .. +1 right)."""
+    a = (pan + 1) * np.pi / 4
+    return np.stack([sig * np.cos(a), sig * np.sin(a)], axis=1)
+
+def normalize(sig, peak=0.9):
+    m = np.abs(sig).max()
+    return sig if m == 0 else sig * (peak / m)

shipwright/engine.py

@@ -0,0 +1,55 @@
+"""The DawDreamer spine: build a processor graph from a RenderSpec
+(instruments -> per-track gain -> master sum -> bus FX), render offline,
+return stereo samples. Also handles writing Buffers (SFX) straight out."""
+import numpy as np
+import dawdreamer as daw
+from .config import SR, BLOCK, MASTER_CEILING
+from .registry import Buffer, RenderSpec
+
+def _limit(audio):
+    m = float(np.abs(audio).max())
+    if m > MASTER_CEILING:
+        audio = audio * (MASTER_CEILING / m)
+    return audio.astype(np.float32)
+
+def render_buffer(buf: Buffer):
+    s = np.asarray(buf.samples, dtype=np.float32)
+    return _limit(s)
+
+def render_spec(spec: RenderSpec):
+    engine = daw.RenderEngine(SR, BLOCK)
+    nodes, track_outs = [], []
+
+    if spec.duration is not None:
+        dur = spec.duration
+    else:
+        end = max((n.start + n.dur for tr in spec.tracks for n in tr.notes), default=1.0)
+        dur = end + 2.0   # tail for releases/reverb
+
+    for i, tr in enumerate(spec.tracks):
+        inst = engine.make_faust_processor(f"inst{i}")
+        inst.set_dsp_string(tr.instrument.dsp)
+        inst.num_voices = tr.instrument.num_voices
+        for n in tr.notes:
+            inst.add_midi_note(n.pitch, n.vel, n.start, n.dur)
+        nodes.append((inst, [])); last = f"inst{i}"
+
+        for j, fx in enumerate(tr.fx):
+            p = engine.make_faust_processor(f"fx{i}_{j}"); p.set_dsp_string(fx)
+            nodes.append((p, [last])); last = f"fx{i}_{j}"
+
+        lin = 10 ** (tr.gain_db / 20.0)
+        g = engine.make_faust_processor(f"g{i}")
+        g.set_dsp_string(f"process = _,_ : *({lin}),*({lin});")
+        nodes.append((g, [last])); track_outs.append(f"g{i}")
+
+    master = engine.make_add_processor("master", [1.0] * len(track_outs))
+    nodes.append((master, track_outs)); last = "master"
+
+    for k, mfx in enumerate(spec.master_fx):
+        p = engine.make_faust_processor(f"m{k}"); p.set_dsp_string(mfx)
+        nodes.append((p, [last])); last = f"m{k}"
+
+    engine.load_graph(nodes)
+    engine.render(dur)
+    return _limit(engine.get_audio().T)   # (n, 2)

shipwright/instruments.py

@@ -0,0 +1,63 @@
+"""The sound-source layer. DawDreamer has no instruments of its own, so we
+supply them. These are Faust programs compiled inside the engine -> zero
+external files, fully reproducible. Swap any of these for a SoundFont or a
+VST later (see README) when you want more 'produced' instruments."""
+from .registry import Instrument
+
+# Faust convention for a polyphonic instrument: expose freq/gain/gate; the
+# engine drives them from MIDI. `effect = _,_;` silences the poly warning.
+_HEAD = 'import("stdfaust.lib");\n'
+
+def saw_lead(cutoff=1500, voices=8):
+    dsp = _HEAD + f"""
+    freq=hslider("freq",440,20,8000,0.01);
+    gain=hslider("gain",0.4,0,1,0.01);
+    gate=button("gate");
+    env=en.adsr(0.01,0.15,0.6,0.25,gate);
+    process=os.sawtooth(freq)*env*gain : fi.resonlp({cutoff},2,1) <: _,_;
+    effect=_,_;
+    """
+    return Instrument("saw_lead", dsp, voices)
+
+def soft_pad(cutoff=1200, voices=8):
+    dsp = _HEAD + f"""
+    freq=hslider("freq",220,20,8000,0.01);
+    gain=hslider("gain",0.3,0,1,0.01);
+    gate=button("gate");
+    env=en.adsr(0.6,0.4,0.8,1.2,gate);
+    osc=(os.sawtooth(freq)+os.sawtooth(freq*1.006)+os.sawtooth(freq*0.994))/3;
+    process=osc*env*gain : fi.lowpass(2,{cutoff}) <: _,_;
+    effect=_,_;
+    """
+    return Instrument("soft_pad", dsp, voices)
+
+def sub_bass(voices=4):
+    dsp = _HEAD + """
+    freq=hslider("freq",110,20,4000,0.01);
+    gain=hslider("gain",0.5,0,1,0.01);
+    gate=button("gate");
+    env=en.adsr(0.01,0.1,0.9,0.2,gate);
+    process=(os.triangle(freq)*0.7+os.osc(freq)*0.3)*env*gain <: _,_;
+    effect=_,_;
+    """
+    return Instrument("sub_bass", dsp, voices)
+
+def pluck(voices=8):
+    dsp = _HEAD + """
+    freq=hslider("freq",440,20,8000,0.01);
+    gain=hslider("gain",0.5,0,1,0.01);
+    gate=button("gate");
+    process=pm.ks(freq, gate)*gain <: _,_;
+    effect=_,_;
+    """
+    return Instrument("pluck", dsp, voices)
+
+# ---- bus / master effects (2 in -> 2 out) --------------------------------
+def reverb(wet=0.3):
+    return _HEAD + f"""
+    wet={wet};
+    process = _,_ <:
+      (_*(1.0-wet), _*(1.0-wet)),
+      (re.stereo_freeverb(0.72,0.5,0.5,23) : _*wet, _*wet)
+      :> _,_;
+    """

shipwright/registry.py

@@ -0,0 +1,57 @@
+"""The vocabulary you author in: a @sound registry plus the data types
+that describe a sound. A sound build-function returns EITHER:
+  - a Buffer       (raw samples you synthesised in numpy -> SFX)
+  - a RenderSpec   (tracks of MIDI played by instruments -> music)
+The harness looks at the type and routes it to the right renderer.
+"""
+from dataclasses import dataclass, field
+from typing import List, Optional
+import numpy as np
+from .config import SR
+
+_REGISTRY = {}
+
+def sound(name):
+    """Decorator: register a build-function under a name."""
+    def deco(fn):
+        _REGISTRY[name] = fn
+        return fn
+    return deco
+
+def get(name):   return _REGISTRY[name]
+def names():     return sorted(_REGISTRY)
+def clear():     _REGISTRY.clear()
+
+# ---- SFX path -------------------------------------------------------------
+@dataclass
+class Buffer:
+    samples: np.ndarray      # (n,) mono or (n, 2) stereo, float -1..1
+    sr: int = SR
+
+# ---- Music path -----------------------------------------------------------
+@dataclass
+class Note:
+    pitch: int               # MIDI note number (60 = middle C)
+    start: float             # seconds
+    dur: float               # seconds
+    vel: int = 100           # 1..127
+
+@dataclass
+class Instrument:
+    name: str
+    dsp: str                 # a Faust program (the sound source)
+    num_voices: int = 8      # >0 makes it a polyphonic MIDI instrument
+
+@dataclass
+class Track:
+    instrument: Instrument
+    notes: List[Note]
+    gain_db: float = 0.0
+    fx: List[str] = field(default_factory=list)   # per-track Faust effects
+
+@dataclass
+class RenderSpec:
+    tracks: List[Track]
+    tempo: float = 120.0
+    duration: Optional[float] = None              # auto from notes if None
+    master_fx: List[str] = field(default_factory=list)  # bus effects (reverb...)

shipwright_audio-0.1.0.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: shipwright-audio
+Version: 0.1.0
+Summary: A code-first audio studio: write -> render -> listen -> adjust.
+Project-URL: Homepage, https://github.com/dinger086/shipwright-audio
+Project-URL: Repository, https://github.com/dinger086/shipwright-audio
+Project-URL: Issues, https://github.com/dinger086/shipwright-audio/issues
+Project-URL: Changelog, https://github.com/dinger086/shipwright-audio/blob/main/CHANGELOG.md
+Author: Robert Braun
+License-Expression: MIT
+License-File: LICENSE
+Keywords: audio,dawdreamer,faust,music,sfx,synthesis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: <3.13,>=3.10
+Requires-Dist: dawdreamer
+Requires-Dist: numpy
+Requires-Dist: scipy<1.15,>=1.11
+Requires-Dist: soundfile
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Provides-Extra: midi
+Requires-Dist: pretty-midi; extra == 'midi'
+Provides-Extra: soundfont
+Requires-Dist: pyfluidsynth; extra == 'soundfont'
+Provides-Extra: theory
+Requires-Dist: music21; extra == 'theory'
+Description-Content-Type: text/markdown
+
+# shipwright-audio
+
+A code-first audio studio: describe a sound or a few bars of music in a
+small Python function, run one command, get a `.wav`.
+
+Requires Python 3.10 through 3.12.
+
+## The shape
+
+Four layers, cleanly separated:
+
+| Layer | File | Job |
+| --- | --- | --- |
+| **Composition** (above) | `shipwright/compose.py` | chord symbols / pitch lists → `Note`s |
+| **Sound sources** (below) | `shipwright/instruments.py` | Faust synths the engine plays |
+| **SFX synthesis** | `shipwright/dsp.py` | numpy oscillators / noise / envelopes / filters |
+| **The spine** | `shipwright/engine.py` | DawDreamer: graph → mix → bus FX → offline render |
+
+You author in a `sounds/` directory in your project (create it yourself —
+the tool reads `./sounds` from wherever you run it). Each file is one sound.
+A build-function returns either a **`Buffer`** (raw numpy samples → SFX) or a
+**`RenderSpec`** (tracks of MIDI played by instruments → music). The harness
+routes by type. Copy-paste starting points live in [`examples/`](examples/).
+
+## Install
+
+As a tool (gets you the `shipwright` command anywhere):
+
+```bash
+uv tool install shipwright-audio      # or: pipx install shipwright-audio
+```
+
+Or from a checkout for development:
+
+```bash
+uv sync                               # create .venv + install deps
+```
+
+## Use
+
+`shipwright` loads sounds from `./sounds` and writes to `./output` relative
+to the directory you run it in (override with `SHIPWRIGHT_SOUNDS` /
+`SHIPWRIGHT_OUTPUT`).
+
+```bash
+shipwright                       # list sounds
+shipwright sea_bed               # render one  -> output/sea_bed.wav
+shipwright all --ogg             # render all, also write .ogg
+shipwright --watch sea_bed       # re-render on every save (tight loop)
+```
+
+From a checkout without installing, `uv run shipwright ...` or
+`python render.py ...` both work.
+
+## Develop
+
+```bash
+uv run --extra dev pytest
+env SHIPWRIGHT_SOUNDS=examples uv run shipwright ui_blip
+env SHIPWRIGHT_SOUNDS=examples uv run shipwright sea_bed
+```
+
+## Add a sound
+
+Create `sounds/my_thing.py`:
+
+```python
+from shipwright import sound, Buffer, dsp
+
+@sound("zap")
+def zap():
+    s = dsp.ad_env(dsp.saw(220, 0.25), attack=0.001, release=0.2)
+    s = dsp.lowpass(s, 1200)
+    return Buffer(dsp.to_stereo(dsp.normalize(s, 0.9)))
+```
+
+…then `shipwright zap`. Music works the same way but returns a
+`RenderSpec` of `Track`s — see [`examples/music_sea_bed.py`](examples/music_sea_bed.py).
+
+## Why DawDreamer is the spine but not the whole thing
+
+DawDreamer mixes, automates (sample-accurate, via numpy arrays), hosts
+plugins, and renders deterministically offline. It does **not** compose and
+ships **no instruments** — so composition lives above it (`compose.py`) and
+sound sources below it (`instruments.py`, here as Faust). That's the whole
+architecture.
+
+## Nicer instruments (upgrade path)
+
+The built-in Faust synths need zero files. When you want more "produced"
+sound, swap a `Track`'s instrument for either:
+
+- **SoundFont**: drop an `.sf2` in `soundfonts/`, render its MIDI with
+  `pyfluidsynth`, feed the audio into the DawDreamer graph as a track.
+- **VST/AU**: `engine.make_plugin_processor("name", "/path/to/plugin.vst3")`,
+  then `add_midi_note(...)` exactly like the Faust instruments.
+
+## License
+
+`shipwright-audio` is MIT licensed. Its DawDreamer dependency is GPLv3; review
+that license before redistributing bundled applications or generated tooling.

shipwright_audio-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+shipwright/__init__.py,sha256=tj2kYv0zZXfAx2u5_zLmlxO_FWoudZiUWIC3W8A1eVw,148
+shipwright/cli.py,sha256=c5h4zhchsnGgG9ko-jyP2oC3xvQTX7umdKE9ZsjtFxI,4412
+shipwright/compose.py,sha256=C5_5f1nwws0BlcrTQ5E9mwl3M_ZkB1sPYWB3lk1ru-I,1858
+shipwright/config.py,sha256=pNkblcZ1GR3WUTYF15g1MJsOxdwFRgBIZNndvIrkt4s,837
+shipwright/dsp.py,sha256=UXzDEclQeLpBPsr2CBFX4SIl3qg8JwnFq2-hXzODZOI,2614
+shipwright/engine.py,sha256=jizzsjHh5OAd6ai9m0Y0HZv7AHk2p9EYCJpEjhdSAwI,2072
+shipwright/instruments.py,sha256=DY20PpVS-72SrMB_LTrCdWIrNIILpC5gd3GQ_Eq-ot8,2153
+shipwright/registry.py,sha256=o5HUaAfY93khS1QMNRTdliSXMCbz5aPeabwxwKe87XY,1815
+shipwright_audio-0.1.0.dist-info/METADATA,sha256=etbT1BVnA5FqmD2qPeNwGEPUNMGtsBmyO1SYFY7ZLwc,4779
+shipwright_audio-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+shipwright_audio-0.1.0.dist-info/entry_points.txt,sha256=wUamQqOEB0WpNnoB-iRuS_Q3bFPWwcr3CMTCa-lofeI,51
+shipwright_audio-0.1.0.dist-info/licenses/LICENSE,sha256=iSj3J5zohq1ZCIUkJ6oICrNieGcdRnAuEi0DsdS_ynw,1069
+shipwright_audio-0.1.0.dist-info/RECORD,,

shipwright_audio-0.1.0.dist-info/WHEEL

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

shipwright_audio-0.1.0.dist-info/entry_points.txt

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

shipwright_audio-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Braun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.