Add files using upload-large-folder tool

README.md

@@ -0,0 +1,142 @@
+---
+license: cc0-1.0
+pretty_name: ProgrammaticAudio
+language:
+- en
+task_categories:
+- audio-classification
+- text-to-audio
+tags:
+- audio
+- synthetic
+- sound-synthesis
+- audio-captioning
+- webdataset
+size_categories:
+- 100K<n<1M
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: train/*.tar
+---
+
+# ProgrammaticAudio
+
+ProgrammaticAudio is a synthetic audio-text dataset: 103,038 clips (304.4 hours), each with an English caption.
+All audio is computed with numpy and scipy. No recordings, samples or learned models produce the audio. The dataset
+covers 123 signal types in 14 categories, from basic waveforms (sine, square, sawtooth), coloured noise and synthesis
+techniques to filters, effects, drum sounds, test signals and digital silence. It was built as a training source for
+contrastive language-audio models, so that they see clean, precisely described synthetic sounds with known
+parameters (frequency, note, filter, effect).
+
+| | |
+|---|---|
+| Clips | 103,038 |
+| Duration | 304.4 h, 2–20 s per clip (mean 10.6 s) |
+| Audio | FLAC, 48 kHz, 16-bit, mono |
+| Captions | one per clip, English: 94,997 generator templates, 8,041 model rewrites (see below) |
+| Shards | 26 WebDataset tars, `train/0001.tar` … `train/0026.tar`, 4,096 clips per tar (the last one 638) |
+| License | CC0 1.0 |
+
+## Format
+
+Each tar holds pairs `prog_NNNNNN.flac` + `prog_NNNNNN.json`. The JSON fields are:
+
+| Field | Meaning |
+|---|---|
+| `__key__` | sample key, `prog_` + the index in the generation plan |
+| `__url__` | the tar the sample is in |
+| `text` | the caption |
+| `original_text` | only on the 8,041 rewritten captions: the template caption from the generator |
+| `generation_method` | the generator function, e.g. `gen_karplus_strong / numpy+scipy` |
+| `category` | one of the 14 categories below |
+
+Example:
+
+```json
+{"__key__": "prog_000011", "__url__": "ProgrammaticAudio/train/0001.tar", "text": "A very loud, pure 2.9 kHz sine wave",
+ "generation_method": "gen_sine / numpy+scipy", "category": "basic_waveforms"}
+```
+
+Loading:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("gijs/ProgrammaticAudio", split="train", streaming=True)
+sample = next(iter(ds))
+print(sample["json"]["text"], sample["flac"]["sampling_rate"])
+```
+
+## Categories
+
+| Category | Clips | Generators (`gen_<name>`) |
+|---|---:|---|
+| basic_waveforms | 13,000 | sine, square, sawtooth, triangle, pulse_pwm, supersaw, wavetable, sample_hold, bit_noise, unison_detune, drone |
+| noise | 6,000 | white_noise, pink_noise, brown_noise, blue_noise, violet_noise, grey_noise, vinyl_crackle, tape_hiss, filtered_noise |
+| synthesis_techniques | 11,500 | fm, am, ring_mod, additive, subtractive, granular, karplus_strong, physical_model |
+| musical_constructs | 9,438 | chord, arpeggio, scale, interval, melody, harmonic_series, dtmf |
+| pitch_tuning | 5,000 | vibrato, pitch_bend, glide, octaver, harmonizer, detune, formant_shift |
+| filters | 8,000 | lowpass, highpass, bandpass, notch, peaking_eq, shelf_eq, comb_filter, allpass, formant_vowel, filter_sweep, wah, resonance |
+| dynamics | 5,000 | compressor, limiter, gate, sidechain_pump, transient_shaper, ducker, amplitude_sweep |
+| distortion | 6,100 | hard_clip, soft_clip, overdrive, fuzz, tape_saturation, waveshaper, bitcrush, sample_rate_reduce, rectify, wow_flutter, vinyl_lofi |
+| time_effects | 6,000 | delay, slapback, pingpong, multitap, tape_delay, reverb_room, reverb_hall, reverb_plate, reverb_spring, gated_reverb, shimmer_reverb, reverse_reverb |
+| modulation | 5,000 | chorus, flanger, phaser, tremolo, autopan, rotary, freq_shifter, lfo_filter |
+| percussive | 8,000 | kick, snare, hihat, click_pop, clap, drum_pattern |
+| special | 4,000 | silence, near_silence, dc_offset, clipping_max, nyquist, sub_bass, impulse, test_tone, sweep, beating, chirp |
+| editing | 5,000 | reverse, stutter_glitch, beat_repeat, freeze, spectral_blur, vocoder, time_stretch, varispeed, chop_gate |
+| combinations | 11,000 | layered, sequence, with_effects, crossfade, sound_design |
+
+The `combinations` generators layer, sequence, crossfade or process the outputs of the other generators.
+
+## How it was generated
+
+The full generator is in [`generator/`](generator/) (`generate.py`, one module per category in `generators/`,
+shared helpers in `utils.py`, caption vocabularies in `constants.py`). It ran once on a 48-core CPU node:
+`python generate.py --workers 92 --seed 42`.
+
+1. **Plan.** Each generator is registered with a clip count. The plan lists 103,100 samples; sample `i` gets the key
+   `prog_{i:06d}` and its own random generator `numpy.random.default_rng(42 + i)`. All parameters (duration
+   uniform in 2–20 s, frequencies, notes, chord types, filter cutoffs, effect settings, ...) are drawn from it.
+2. **Signal.** The generator function returns the signal at 48 kHz, a list of descriptor words and a core phrase
+   (e.g. `["resonant"]`, `"Karplus-Strong plucked string at G#4"`). Pitched sounds name the frequency or note,
+   filters their cutoff, rhythmic sounds their BPM.
+3. **Level.** The clip is peak-normalised to a random amplitude, uniform in 0.05–1.0. The amplitude sets a volume
+   word: below 0.15 "very quiet", below 0.35 "quiet" or "soft", below 0.65 none, below 0.85 "loud", otherwise
+   "very loud". A 10 ms linear fade is applied at both ends, the signal is clipped to [-1, 1] and written as
+   16-bit FLAC.
+4. **Caption.** The template is `A {volume}, {descriptors} {core}`, for example "A soft, resonant Karplus-Strong
+   plucked string at G#4" or "A 112 BPM shuffle drum pattern with kick, snare, and hi-hat".
+5. **Failures.** 62 `gen_melody` samples raised an error and were dropped, so `musical_constructs` has 9,438 clips
+   instead of 9,500.
+
+Tars are filled in completion order across worker processes, so keys inside a tar are not contiguous.
+
+**Reproducibility.** Running the generator again with seed 42 gives bit-identical audio. We regenerated 40 randomly
+chosen clips and compared the decoded 16-bit PCM: all 40 are identical. The generator reads `TAR_DIR` (output root)
+from the environment and needs numpy, scipy, soundfile and python-dotenv.
+
+## Caption rewrites
+
+After generation, a caption clean-up pass over our whole audio collection replaced captions that had at most 4 words,
+more than 40 words, or were not detected as English by `langdetect`. In this dataset that affected 8,041 clips
+(7.8 %): 2,339 templates with at most 4 words (e.g. "A pink noise", "A DC offset signal") and 5,702 English
+templates that `langdetect` misclassified (e.g. "A quiet, buzzy 815 Hz square wave"). The new caption was written by
+[Qwen3-Omni-30B-A3B-Instruct](https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct), which received the audio and
+the prompt "Write an audio caption for this audio in 1 sentence. For potential context, see original caption:
+{template caption}". The template caption is kept in `original_text`. Use `original_text` when present if you want
+the exact generator description for every clip.
+
+## Known quirks
+
+- The volume word comes from the random peak amplitude, independent of the generator. Every clip is peak-normalised,
+  so `near_silence` clips (Gaussian noise floor) play at a normal level, and some captions combine contradicting
+  words, e.g. "A very loud, barely audible, faint ambient noise floor".
+- `silence` clips are all-zero samples. `dc_offset` clips are a constant value with 10 ms ramps at both ends.
+- Captions are templates. Many clips of the same generator share the same caption except for the numbers.
+
+## License
+
+CC0 1.0. The audio and the template captions are fully synthetic and generated by our own code. The rewritten
+captions were generated by Qwen3-Omni (Apache 2.0).

generator/constants.py

@@ -0,0 +1,89 @@
+"""Musical constants, descriptor pools, and lookup tables."""
+
+NOTE_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+
+CHORD_TYPES = {
+    "major": [0, 4, 7],
+    "minor": [0, 3, 7],
+    "diminished": [0, 3, 6],
+    "augmented": [0, 4, 8],
+    "major seventh": [0, 4, 7, 11],
+    "minor seventh": [0, 3, 7, 10],
+    "dominant seventh": [0, 4, 7, 10],
+    "sus2": [0, 2, 7],
+    "sus4": [0, 5, 7],
+    "power": [0, 7],
+}
+
+SCALE_TYPES = {
+    "major": [0, 2, 4, 5, 7, 9, 11],
+    "natural minor": [0, 2, 3, 5, 7, 8, 10],
+    "harmonic minor": [0, 2, 3, 5, 7, 8, 11],
+    "dorian": [0, 2, 3, 5, 7, 9, 10],
+    "mixolydian": [0, 2, 4, 5, 7, 9, 10],
+    "pentatonic major": [0, 2, 4, 7, 9],
+    "pentatonic minor": [0, 3, 5, 7, 10],
+    "blues": [0, 3, 5, 6, 7, 10],
+    "chromatic": list(range(12)),
+    "whole tone": [0, 2, 4, 6, 8, 10],
+}
+
+INTERVAL_NAMES = {
+    0: "unison", 1: "minor second", 2: "major second", 3: "minor third",
+    4: "major third", 5: "perfect fourth", 6: "tritone", 7: "perfect fifth",
+    8: "minor sixth", 9: "major sixth", 10: "minor seventh", 11: "major seventh",
+    12: "octave",
+}
+
+DTMF_FREQS = {
+    '1': (697, 1209), '2': (697, 1336), '3': (697, 1477),
+    '4': (770, 1209), '5': (770, 1336), '6': (770, 1477),
+    '7': (852, 1209), '8': (852, 1336), '9': (852, 1477),
+    '0': (941, 1336), '*': (941, 1209), '#': (941, 1477),
+}
+
+DRUM_PATTERNS = {
+    "rock": {
+        "kick":  [1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+        "snare": [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+        "hihat": [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+    },
+    "four on the floor": {
+        "kick":  [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
+        "snare": [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+        "hihat": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    },
+    "breakbeat": {
+        "kick":  [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+        "snare": [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1],
+        "hihat": [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+    },
+    "shuffle": {
+        "kick":  [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+        "snare": [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+        "hihat": [1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1],
+    },
+    "funk": {
+        "kick":  [1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+        "snare": [0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0],
+        "hihat": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    },
+}
+
+VOWEL_FORMANTS = {
+    'a': [(730, 80), (1090, 90), (2440, 120)],
+    'e': [(530, 60), (1840, 100), (2480, 120)],
+    'i': [(270, 40), (2290, 110), (3010, 130)],
+    'o': [(570, 70), (840, 80), (2410, 120)],
+    'u': [(300, 50), (870, 80), (2240, 110)],
+}
+
+# Descriptor pools for perceptual qualities
+LOW_DESCS = ["dark", "warm", "thick", "boomy", "deep"]
+HIGH_DESCS = ["bright", "thin", "airy", "crisp", "sharp"]
+DIST_DESCS = ["harsh", "gritty", "crunchy", "aggressive"]
+REVERB_DESCS = ["spacious", "wet", "distant", "ethereal"]
+CLEAN_DESCS = ["clean", "pure", "smooth", "clear"]
+METAL_DESCS = ["metallic", "resonant", "bell-like", "ringy"]
+BUZZ_DESCS = ["buzzy", "nasal", "reedy"]
+SOFT_DESCS = ["smooth", "gentle", "mellow", "warm"]

generator/generate.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""Generate ProgrammaticAudio dataset — 100k+ synthetic audio samples.
+
+Usage:
+    python programmatic_audio/generate.py --workers 92 --seed 42
+"""
+
+import os
+import sys
+
+# Ensure project root is on path for dotenv
+_project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, _project_root)
+
+from dotenv import load_dotenv
+load_dotenv(os.path.join(_project_root, '.env'))
+
+import argparse
+import concurrent.futures
+import io
+import json
+import tarfile
+import time
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+
+sys.stdout.reconfigure(line_buffering=True)
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+from utils import SR, SAMPLES_PER_TAR, _vol_word, _build_caption, _normalize
+
+OUTPUT_DIR = Path(os.environ["TAR_DIR"]) / "ProgrammaticAudio" / "train"
+INFO_DIR = Path(os.environ["TAR_DIR"]) / "ProgrammaticAudio"
+
+# Import registry & all generator modules to trigger registration
+from generators import REGISTRY, GEN_BY_NAME, CAT_BY_NAME
+import generators.waveforms       # noqa: F401
+import generators.noise            # noqa: F401
+import generators.synthesis        # noqa: F401
+import generators.musical          # noqa: F401
+import generators.pitch            # noqa: F401
+import generators.filters          # noqa: F401
+import generators.dynamics         # noqa: F401
+import generators.distortion       # noqa: F401
+import generators.time_effects     # noqa: F401
+import generators.modulation       # noqa: F401
+import generators.percussive       # noqa: F401
+import generators.special          # noqa: F401
+import generators.editing          # noqa: F401
+import generators.combinations     # noqa: F401
+
+
+# ── Sample plan ───────────────────────────────────────────────────────────────
+
+def build_sample_plan():
+    """Build list of (gen_name, global_idx, category) for all samples."""
+    plan = []
+    global_idx = 0
+    for func, count, category in REGISTRY:
+        for _ in range(count):
+            plan.append((func.__name__, global_idx, category))
+            global_idx += 1
+    return plan
+
+
+# ── Single-sample generation (runs in worker process) ─────────────────────────
+
+def generate_one_sample(args):
+    """Generate one audio sample. Returns (key, flac_bytes, meta) or None."""
+    gen_name, global_idx, category, master_seed = args
+    try:
+        rng = np.random.default_rng(master_seed + global_idx)
+        gen_func = GEN_BY_NAME[gen_name]
+
+        # Generate audio + caption parts
+        audio, descriptors, core = gen_func(rng)
+        if audio is None or len(audio) == 0:
+            return None
+
+        # Sanitize audio
+        if not np.isfinite(audio).all():
+            audio = np.nan_to_num(audio, nan=0.0, posinf=0.0, neginf=0.0)
+        audio = audio.astype(np.float64)
+
+        # Random volume & normalize
+        amplitude = rng.uniform(0.05, 1.0)
+        peak = np.max(np.abs(audio))
+        if peak > 1e-10:
+            audio = audio * (amplitude / peak)
+
+        vol = _vol_word(rng, amplitude)
+        caption = _build_caption(vol, descriptors, core)
+
+        # Fade in/out (10 ms)
+        fade_n = min(int(0.01 * SR), len(audio) // 4)
+        if fade_n > 1:
+            audio[:fade_n] *= np.linspace(0, 1, fade_n)
+            audio[-fade_n:] *= np.linspace(1, 0, fade_n)
+
+        # Clip
+        audio = np.clip(audio, -1.0, 1.0)
+
+        # Encode FLAC
+        buf = io.BytesIO()
+        sf.write(buf, audio.astype(np.float32), SR, subtype='PCM_16', format='FLAC')
+        flac_bytes = buf.getvalue()
+
+        key = f"prog_{global_idx:06d}"
+        tar_idx = global_idx // SAMPLES_PER_TAR + 1
+        meta = {
+            "__key__": key,
+            "__url__": f"ProgrammaticAudio/train/{tar_idx:04d}.tar",
+            "text": caption,
+            "generation_method": f"{gen_name} / numpy+scipy",
+            "category": category,
+        }
+        return (key, flac_bytes, meta)
+
+    except Exception:
+        return None
+
+
+# ── Tar writing ───────────────────────────────────────────────────────────────
+
+def write_tar(samples, tar_path):
+    tar_path.parent.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(tar_path, "w") as tar:
+        for key, flac_bytes, meta in samples:
+            fi = tarfile.TarInfo(name=f"{key}.flac")
+            fi.size = len(flac_bytes)
+            tar.addfile(fi, io.BytesIO(flac_bytes))
+            jb = json.dumps(meta, ensure_ascii=False).encode("utf-8")
+            ji = tarfile.TarInfo(name=f"{key}.json")
+            ji.size = len(jb)
+            tar.addfile(ji, io.BytesIO(jb))
+    return len(samples)
+
+
+def write_info_md(total_samples, total_tars):
+    INFO_DIR.mkdir(parents=True, exist_ok=True)
+    # Gather category counts
+    cat_counts = {}
+    for _, count, cat in REGISTRY:
+        cat_counts[cat] = cat_counts.get(cat, 0) + count
+    cat_table = "\n".join(f"| {c} | {n:,} |" for c, n in sorted(cat_counts.items()))
+
+    info = f"""# ProgrammaticAudio Dataset
+
+## Description
+Synthetic audio dataset covering programmatically-generated waveforms, noise,
+synthesis techniques, effects, dynamics, spatial characteristics, and perceptual
+qualities. All generated purely with numpy and scipy — no real-world recordings.
+
+## License
+Public domain / CC0 — fully synthetic, no copyright concerns.
+
+## Format
+- Audio: FLAC, 48 kHz, 16-bit, mono
+- Duration: 2–20 seconds per sample
+- Metadata: JSON with `__key__`, `__url__`, `text`, `generation_method`, `category`
+- Max {SAMPLES_PER_TAR} samples per tar
+
+## Statistics
+- Total samples generated: {total_samples:,}
+- Total tar files: {total_tars}
+
+## Categories
+| Category | Target Count |
+|----------|-------------|
+{cat_table}
+
+## Generation
+- Tool: `programmatic_audio/generate.py`
+- Dependencies: numpy, scipy, soundfile
+"""
+    (INFO_DIR / "info.md").write_text(info)
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate ProgrammaticAudio dataset")
+    parser.add_argument("--workers", type=int, default=92)
+    parser.add_argument("--seed", type=int, default=42)
+    args = parser.parse_args()
+
+    plan = build_sample_plan()
+    total_plan = len(plan)
+    print(f"Registered {len(REGISTRY)} generators, {total_plan:,} total samples planned")
+    print(f"Workers: {args.workers}, Seed: {args.seed}")
+    print(f"Output: {OUTPUT_DIR}")
+
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    total_ok = 0
+    total_fail = 0
+    tar_idx = 0
+    buffer = []
+    t_start = time.time()
+
+    pool = ProcessPoolExecutor(max_workers=args.workers)
+    pending = set()
+    MAX_PENDING = args.workers * 3
+
+    def _flush():
+        nonlocal tar_idx
+        tar_idx += 1
+        path = OUTPUT_DIR / f"{tar_idx:04d}.tar"
+        n = write_tar(buffer, path)
+        print(f"  Wrote {tar_idx:04d}.tar ({n} samples)")
+        buffer.clear()
+
+    def drain():
+        nonlocal total_ok, total_fail
+        done = {f for f in pending if f.done()}
+        for f in done:
+            pending.discard(f)
+            result = f.result()
+            if result is None:
+                total_fail += 1
+            else:
+                buffer.append(result)
+                total_ok += 1
+                if len(buffer) >= SAMPLES_PER_TAR:
+                    _flush()
+
+    def wait_below(threshold):
+        nonlocal total_ok, total_fail
+        while len(pending) > threshold:
+            done_set, _ = concurrent.futures.wait(
+                pending, return_when=concurrent.futures.FIRST_COMPLETED)
+            pending.difference_update(done_set)
+            for f in done_set:
+                result = f.result()
+                if result is None:
+                    total_fail += 1
+                else:
+                    buffer.append(result)
+                    total_ok += 1
+                    if len(buffer) >= SAMPLES_PER_TAR:
+                        _flush()
+
+    for i, (gen_name, global_idx, category) in enumerate(plan):
+        if len(pending) >= MAX_PENDING:
+            wait_below(MAX_PENDING // 2)
+
+        task_args = (gen_name, global_idx, category, args.seed)
+        pending.add(pool.submit(generate_one_sample, task_args))
+
+        if (i + 1) % 5000 == 0 or i == 0:
+            drain()
+            elapsed = time.time() - t_start
+            rate = (total_ok + total_fail) / elapsed if elapsed > 0 else 0
+            eta = (total_plan - i) / rate if rate > 0 else 0
+            print(f"[{i + 1:,}/{total_plan:,}] ok={total_ok:,} fail={total_fail:,} "
+                  f"pending={len(pending)} rate={rate:.1f}/s ETA={eta:.0f}s")
+
+    print(f"Draining {len(pending)} remaining futures...")
+    wait_below(0)
+
+    if buffer:
+        _flush()
+
+    pool.shutdown()
+    elapsed = time.time() - t_start
+    print(f"\nDONE: {total_ok:,} samples, {total_fail:,} failures, "
+          f"{tar_idx} tars, {elapsed:.0f}s")
+
+    write_info_md(total_ok, tar_idx)
+    print(f"Wrote {INFO_DIR / 'info.md'}")
+
+
+if __name__ == "__main__":
+    main()

generator/generators/__init__.py

@@ -0,0 +1,15 @@
+"""Generator registry for programmatic audio generation."""
+
+REGISTRY = []   # [(func, count, category), ...]
+GEN_BY_NAME = {}  # {name: func}
+CAT_BY_NAME = {}  # {name: category}
+
+
+def register(count, category):
+    """Decorator to register a generator function with sample count and category."""
+    def decorator(func):
+        REGISTRY.append((func, count, category))
+        GEN_BY_NAME[func.__name__] = func
+        CAT_BY_NAME[func.__name__] = category
+        return func
+    return decorator

generator/generators/combinations.py

@@ -0,0 +1,188 @@
+"""Category N: Combinations & Layers — 11,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _freq_str,
+                   _random_base, _random_source, _pick, _normalize,
+                   _chorus, _flanger, _compress, _apply_reverb, _reverb_ir,
+                   _apply_delay, _sidechain_pump, _safe_butter, _apply_sos)
+from constants import CLEAN_DESCS, SOFT_DESCS, REVERB_DESCS
+
+
+@register(3000, "combinations")
+def gen_layered(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    n_layers = int(rng.integers(2, 5))
+    audio = np.zeros(n)
+    layer_descs = []
+    for _ in range(n_layers):
+        layer, desc, _ = _random_source(rng, n)
+        layer *= rng.uniform(0.3, 1.0)
+        audio += layer
+        layer_descs.append(desc)
+    if len(layer_descs) == 2:
+        core = f"layered sound combining {layer_descs[0]} and {layer_descs[1]}"
+    else:
+        core = f"layered sound combining {', '.join(layer_descs[:-1])}, and {layer_descs[-1]}"
+    return audio, _pick(rng, ["rich", "complex", "dense", "full"]), core
+
+
+@register(2000, "combinations")
+def gen_sequence(rng):
+    dur = _dur(rng, 4, 20)
+    n = _ns(dur)
+    n_parts = int(rng.integers(2, 5))
+    part_len = n // n_parts
+    audio = np.zeros(n)
+    part_descs = []
+    for i in range(n_parts):
+        start = i * part_len
+        end = min(start + part_len, n)
+        part, desc, _ = _random_source(rng, end - start)
+        audio[start:end] = part[:end - start]
+        part_descs.append(desc)
+    # Crossfade between parts
+    fade = min(int(0.02 * SR), part_len // 4)
+    for i in range(1, n_parts):
+        pos = i * part_len
+        if pos + fade <= n and pos - fade >= 0:
+            audio[pos - fade:pos] *= np.linspace(1, 0, fade)
+            audio[pos:pos + fade] *= np.linspace(0, 1, fade)
+    if len(part_descs) == 2:
+        core = f"sequence of {part_descs[0]} and {part_descs[1]}"
+    else:
+        core = f"sequence of {', '.join(part_descs[:-1])}, and {part_descs[-1]}"
+    return audio, _pick(rng, ["varied", "evolving"]), core
+
+
+@register(4000, "combinations")
+def gen_with_effects(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    # Apply 2-4 random effects
+    effect_pool = [
+        ("chorus", lambda a, r: _chorus(a, r)),
+        ("compression", lambda a, r: _compress(a, r.uniform(-20, -5), r.uniform(2, 8))),
+        ("reverb", lambda a, r: _apply_reverb(a, _reverb_ir(r, r.uniform(0.5, 3), "hall"),
+                                                r.uniform(0.2, 0.5))),
+        ("delay", lambda a, r: _apply_delay(a, r.uniform(0.1, 0.4), r.uniform(0.3, 0.6),
+                                              r.uniform(0.2, 0.4))),
+        ("flanger", lambda a, r: _flanger(a, r)),
+        ("distortion", lambda a, r: np.tanh(a * r.uniform(2, 6))),
+        ("low-pass filter", lambda a, r: _apply_sos(a, _safe_butter(
+            3, _log_uniform(r, 500, 5000), 'low'))),
+        ("high-pass filter", lambda a, r: _apply_sos(a, _safe_butter(
+            3, _log_uniform(r, 200, 3000), 'high'))),
+    ]
+    n_effects = int(rng.integers(2, 5))
+    chosen = rng.choice(len(effect_pool), size=min(n_effects, len(effect_pool)), replace=False)
+    effect_names = []
+    for idx in chosen:
+        name, func = effect_pool[int(idx)]
+        try:
+            audio = func(audio, rng)
+        except Exception:
+            continue
+        effect_names.append(name)
+    if not effect_names:
+        effect_names = ["processing"]
+    if len(effect_names) == 1:
+        fx_str = effect_names[0]
+    elif len(effect_names) == 2:
+        fx_str = f"{effect_names[0]} and {effect_names[1]}"
+    else:
+        fx_str = ", ".join(effect_names[:-1]) + f", and {effect_names[-1]}"
+    return audio, _pick(rng, ["processed", "layered", "thick"]), \
+        f"{desc} with {fx_str}"
+
+
+@register(1000, "combinations")
+def gen_crossfade(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio_a, desc_a, _ = _random_source(rng, n)
+    audio_b, desc_b, _ = _random_source(rng, n)
+    fade = np.linspace(0, 1, n)
+    audio = (1 - fade) * audio_a + fade * audio_b
+    return audio, _pick(rng, ["evolving", "morphing", "transitioning"]), \
+        f"crossfade from {desc_a} into {desc_b}"
+
+
+@register(1000, "combinations")
+def gen_sound_design(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Start with synthesis
+    synth_type = int(rng.integers(0, 4))
+    t = _t(n)
+    if synth_type == 0:
+        # FM
+        carrier = _log_uniform(rng, 100, 1000)
+        index = rng.uniform(1, 8)
+        ratio = float(rng.choice([1, 2, 3]))
+        audio = np.sin(2 * np.pi * carrier * t + index * np.sin(2 * np.pi * carrier * ratio * t))
+        base_desc = "FM synthesis"
+    elif synth_type == 1:
+        # Granular texture
+        grain_size = int(rng.uniform(0.01, 0.05) * SR)
+        window = np.hanning(grain_size)
+        audio = np.zeros(n)
+        src = rng.standard_normal(n)
+        for _ in range(int(rng.uniform(20, 80) * dur)):
+            sp = int(rng.integers(0, max(n - grain_size, 1)))
+            op = int(rng.integers(0, max(n - grain_size, 1)))
+            end = min(op + grain_size, n)
+            gl = end - op
+            audio[op:end] += src[sp:sp + gl] * window[:gl]
+        base_desc = "granular texture"
+    elif synth_type == 2:
+        # Additive with movement
+        freq = _log_uniform(rng, 100, 500)
+        audio = np.zeros(n)
+        for h in range(1, int(rng.integers(5, 15))):
+            f = freq * h
+            if f > SR / 2:
+                break
+            lfo = 0.5 + 0.5 * np.sin(2 * np.pi * rng.uniform(0.05, 0.5) * t)
+            audio += lfo * np.sin(2 * np.pi * f * t) / h
+        base_desc = "evolving additive synthesis"
+    else:
+        audio, base_desc, _ = _random_source(rng, n)
+    # Apply 2-3 effects
+    effects = []
+    if rng.random() < 0.7:
+        # Filter sweep
+        f_start = _log_uniform(rng, 200, 5000)
+        f_end = _log_uniform(rng, 200, 5000)
+        block = 512
+        freqs = np.geomspace(f_start, f_end, n // block + 1)
+        out = np.zeros(n)
+        for i in range(0, n, block):
+            end = min(i + block, n)
+            f = float(np.clip(freqs[i // block], 20, SR / 2 - 100))
+            sos = _safe_butter(2, f, 'low')
+            if sos is not None:
+                out[i:end] = _apply_sos(audio[i:end], sos)
+            else:
+                out[i:end] = audio[i:end]
+        audio = out
+        effects.append("filter sweep")
+    if rng.random() < 0.6:
+        ir = _reverb_ir(rng, rng.uniform(1, 4), "hall")
+        audio = _apply_reverb(audio, ir, rng.uniform(0.2, 0.5))
+        effects.append("reverb")
+    if rng.random() < 0.5:
+        audio = np.tanh(audio * rng.uniform(1.5, 4))
+        effects.append("saturation")
+    fx_str = ""
+    if effects:
+        if len(effects) == 1:
+            fx_str = f" with {effects[0]}"
+        else:
+            fx_str = f" with {', '.join(effects[:-1])}, and {effects[-1]}"
+    return audio, _pick(rng, ["evolving", "complex", "textural", "atmospheric"]), \
+        f"sound design texture: {base_desc}{fx_str}"

generator/generators/distortion.py

@@ -0,0 +1,177 @@
+"""Category H: Distortion / Saturation / Lo-fi — 6,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _wave, _freq_str,
+                   _random_base, _pick, _safe_butter, _apply_sos, _normalize)
+from constants import DIST_DESCS, LOW_DESCS, HIGH_DESCS, SOFT_DESCS, BUZZ_DESCS
+
+
+@register(600, "distortion")
+def gen_hard_clip(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    drive = rng.uniform(2, 10)
+    threshold = rng.uniform(0.2, 0.6)
+    audio = np.clip(audio * drive, -threshold, threshold) / threshold
+    return audio, _pick(rng, DIST_DESCS), f"hard-clipped {desc}"
+
+
+@register(600, "distortion")
+def gen_soft_clip(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    drive = rng.uniform(2, 8)
+    audio = np.tanh(audio * drive)
+    return audio, _pick(rng, SOFT_DESCS + ["saturated"]), f"soft-clipped {desc}"
+
+
+@register(600, "distortion")
+def gen_overdrive(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    drive = rng.uniform(3, 15)
+    # Asymmetric soft clip
+    audio = audio * drive
+    pos = audio > 0
+    neg = audio < 0
+    audio[pos] = 1 - np.exp(-audio[pos])
+    audio[neg] = -(1 - np.exp(audio[neg])) * 0.8
+    return audio, _pick(rng, ["gritty", "overdriven", "warm", "driven"]), \
+        f"overdriven {desc}"
+
+
+@register(600, "distortion")
+def gen_fuzz(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    drive = rng.uniform(10, 50)
+    audio = np.sign(audio) * (1 - np.exp(-np.abs(audio * drive)))
+    return audio, _pick(rng, ["aggressive", "fuzzy", "destroyed", "extreme"]), \
+        f"fuzzy {desc}"
+
+
+@register(500, "distortion")
+def gen_tape_saturation(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    drive = rng.uniform(1.5, 5)
+    audio = np.tanh(audio * drive) * 0.9
+    # Tape-like frequency response: slight high cut, bass bump
+    sos_lp = _safe_butter(2, rng.uniform(8000, 14000), 'low')
+    if sos_lp is not None:
+        audio = _apply_sos(audio, sos_lp)
+    return audio, _pick(rng, ["warm", "saturated", "analog", "tape-like"]), \
+        f"tape-saturated {desc}"
+
+
+@register(600, "distortion")
+def gen_waveshaper(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    # Chebyshev polynomial waveshaping
+    order = int(rng.integers(2, 6))
+    audio_clipped = np.clip(audio, -1, 1)
+    shaped = np.polynomial.chebyshev.chebval(audio_clipped,
+                                              [0] * order + [1])
+    return _normalize(shaped), _pick(rng, DIST_DESCS + ["complex"]), \
+        f"waveshaped {desc} with Chebyshev polynomial distortion"
+
+
+@register(600, "distortion")
+def gen_bitcrush(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    bits = int(rng.integers(2, 8))
+    levels = 2 ** bits
+    audio = np.round(audio * levels / 2) / (levels / 2)
+    return audio, _pick(rng, ["crunchy", "lo-fi", "digital", "retro"]), \
+        f"{bits}-bit bitcrushed {desc}"
+
+
+@register(500, "distortion")
+def gen_sample_rate_reduce(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    target_sr = int(_log_uniform(rng, 2000, 16000))
+    factor = max(SR // target_sr, 2)
+    # Decimate by holding samples
+    indices = np.repeat(np.arange(0, n, factor), factor)[:n]
+    audio = audio[indices]
+    return audio, _pick(rng, ["lo-fi", "decimated", "aliased", "crunchy"]), \
+        f"lo-fi {desc} at {target_sr} Hz effective sample rate"
+
+
+@register(500, "distortion")
+def gen_rectify(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 50, 2000)
+    t = _t(n)
+    audio = np.sin(2 * np.pi * freq * t)
+    rect_type = str(rng.choice(["half", "full"]))
+    if rect_type == "half":
+        audio = np.maximum(audio, 0)
+    else:
+        audio = np.abs(audio)
+    return audio, _pick(rng, BUZZ_DESCS + ["distorted"]), \
+        f"{rect_type}-wave rectified {_freq_str(freq)} sine"
+
+
+@register(500, "distortion")
+def gen_wow_flutter(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    # Wow: slow pitch drift (0.5-3 Hz)
+    wow_rate = rng.uniform(0.5, 3)
+    wow_depth = rng.uniform(0.002, 0.01)
+    # Flutter: fast pitch drift (5-15 Hz)
+    flutter_rate = rng.uniform(5, 15)
+    flutter_depth = rng.uniform(0.0005, 0.002)
+    t = _t(n)
+    mod = wow_depth * np.sin(2 * np.pi * wow_rate * t) + \
+          flutter_depth * np.sin(2 * np.pi * flutter_rate * t)
+    # Time-varying delay for pitch modulation
+    delay_samples = (mod * SR).astype(int)
+    indices = np.arange(n) - delay_samples
+    indices = np.clip(indices, 0, n - 1)
+    audio = audio[indices]
+    return audio, _pick(rng, ["wobbly", "warped", "degraded", "tape-like"]), \
+        f"{desc} with tape-like wow and flutter pitch drift"
+
+
+@register(500, "distortion")
+def gen_vinyl_lofi(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    # Warmth: light saturation + low-pass
+    audio = np.tanh(audio * rng.uniform(1.2, 2.5))
+    sos = _safe_butter(2, rng.uniform(6000, 12000), 'low')
+    if sos is not None:
+        audio = _apply_sos(audio, sos)
+    # Add crackle
+    n_crackles = int(rng.uniform(3, 30) * dur)
+    for _ in range(n_crackles):
+        pos = int(rng.integers(0, n))
+        cl = min(int(rng.uniform(0.0001, 0.001) * SR), n - pos)
+        audio[pos:pos + cl] += rng.uniform(0.1, 0.4) * float(rng.choice([-1, 1]))
+    # Subtle rumble
+    rumble = rng.standard_normal(n) * 0.02
+    sos_lp = _safe_butter(2, 80, 'low')
+    if sos_lp is not None:
+        rumble = _apply_sos(rumble, sos_lp)
+    audio += rumble
+    return audio, _pick(rng, ["lo-fi", "warm", "vintage", "worn"]), \
+        f"lo-fi {desc} with vinyl crackle and warmth"

generator/generators/dynamics.py

@@ -0,0 +1,139 @@
+"""Category G: Dynamics Processing — 5,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _freq_str, _random_base,
+                   _pick, _compress, _sidechain_pump, _safe_butter, _apply_sos)
+from constants import CLEAN_DESCS, LOW_DESCS, SOFT_DESCS
+
+
+@register(800, "dynamics")
+def gen_compressor(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    threshold = rng.uniform(-20, -5)
+    ratio = rng.uniform(2, 10)
+    audio = _compress(audio, threshold, ratio)
+    return audio, _pick(rng, ["punchy", "squashed", "controlled", "tight"]), \
+        f"compressed {desc}"
+
+
+@register(500, "dynamics")
+def gen_limiter(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    ceiling = rng.uniform(0.3, 0.8)
+    audio = np.clip(audio, -ceiling, ceiling) / ceiling
+    return audio, _pick(rng, ["loud", "squashed", "brickwalled"]), \
+        f"hard-limited {desc}"
+
+
+@register(600, "dynamics")
+def gen_gate(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    gate_rate = rng.uniform(2, 16)
+    t = _t(n)
+    # Rhythmic gate
+    gate_env = (np.sin(2 * np.pi * gate_rate * t) > rng.uniform(-0.5, 0.3)).astype(float)
+    # Smooth edges
+    smooth_samples = int(0.005 * SR)
+    if smooth_samples > 1:
+        kernel = np.ones(smooth_samples) / smooth_samples
+        gate_env = np.convolve(gate_env, kernel, mode='same')
+    audio *= gate_env
+    return audio, _pick(rng, ["choppy", "rhythmic", "stuttering"]), \
+        f"noise-gated {desc} creating rhythmic stutters"
+
+
+@register(1000, "dynamics")
+def gen_sidechain_pump(rng):
+    dur = _dur(rng, 4, 20)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    bpm = rng.uniform(100, 160)
+    depth = rng.uniform(0.5, 0.95)
+    curve = rng.uniform(2, 5)
+    audio = _sidechain_pump(audio, bpm, depth, curve)
+    return audio, _pick(rng, ["pumping", "pulsing", "ducking", "rhythmic"]), \
+        f"{desc} with heavy sidechain pumping at {bpm:.0f} BPM"
+
+
+@register(600, "dynamics")
+def gen_transient_shaper(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Generate a percussive base
+    freq = _log_uniform(rng, 100, 2000)
+    t = _t(n)
+    audio = np.sin(2 * np.pi * freq * t)
+    # Create repeating transients
+    hit_rate = rng.uniform(2, 8)
+    period = int(SR / hit_rate)
+    env = np.zeros(n)
+    for pos in range(0, n, period):
+        click_len = min(int(rng.uniform(0.001, 0.01) * SR), n - pos)
+        env[pos:pos + click_len] += np.exp(-np.arange(click_len) / (0.002 * SR))
+    # Enhance transients
+    attack_gain = rng.uniform(2, 6)
+    env_boost = 1.0 + (attack_gain - 1) * np.minimum(env, 1.0)
+    audio *= env_boost
+    return audio, _pick(rng, ["snappy", "punchy", "sharp", "transient"]), \
+        f"transient-enhanced click pattern at {_freq_str(freq)}"
+
+
+@register(500, "dynamics")
+def gen_ducker(rng):
+    dur = _dur(rng, 4, 20)
+    n = _ns(dur)
+    # Background: noise
+    bg = rng.standard_normal(n) * 0.5
+    sos = _safe_butter(2, 3000, 'low')
+    if sos is not None:
+        bg = _apply_sos(bg, sos)
+    # Foreground: tone that appears periodically
+    freq = _log_uniform(rng, 200, 1000)
+    t = _t(n)
+    tone = np.sin(2 * np.pi * freq * t)
+    period = rng.uniform(1, 3)
+    period_samples = int(period * SR)
+    tone_dur = int(rng.uniform(0.2, 0.8) * period_samples)
+    # Create ducking envelope
+    duck_env = np.ones(n)
+    tone_env = np.zeros(n)
+    for pos in range(0, n, period_samples):
+        end = min(pos + tone_dur, n)
+        tone_env[pos:end] = 1.0
+        duck_env[pos:end] = 0.2
+    # Smooth
+    sm = int(0.02 * SR)
+    if sm > 1:
+        kernel = np.ones(sm) / sm
+        duck_env = np.convolve(duck_env, kernel, mode='same')
+        tone_env = np.convolve(tone_env, kernel, mode='same')
+    audio = bg * duck_env + tone * tone_env * 0.5
+    return audio, _pick(rng, ["ducking", "dynamic"]), \
+        f"noise bed that ducks when a {_freq_str(freq)} tone plays"
+
+
+@register(1000, "dynamics")
+def gen_amplitude_sweep(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    direction = str(rng.choice(["crescendo", "decrescendo"]))
+    curve = rng.uniform(0.5, 3)
+    if direction == "crescendo":
+        env = np.linspace(0, 1, n) ** curve
+        sweep_desc = "crescendo from silence to loud"
+    else:
+        env = np.linspace(1, 0, n) ** curve
+        sweep_desc = "decrescendo from loud to silence"
+    audio *= env
+    return audio, _pick(rng, ["sweeping", "dynamic", "evolving"]), \
+        f"{sweep_desc} {desc}"

generator/generators/editing.py

@@ -0,0 +1,225 @@
+"""Category M: Editing / Special Processing — 5,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _wave, _freq_str,
+                   _random_base, _random_source, _pick, _normalize,
+                   _safe_butter, _apply_sos, _make_kick, _make_snare)
+from constants import CLEAN_DESCS, METAL_DESCS
+
+
+@register(600, "editing")
+def gen_reverse(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    audio = audio[::-1].copy()
+    return audio, _pick(rng, ["reversed", "backwards"]), f"reversed {desc}"
+
+
+@register(800, "editing")
+def gen_stutter_glitch(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    # Pick a short fragment and repeat it
+    frag_len = int(rng.uniform(0.01, 0.1) * SR)
+    frag_start = int(rng.integers(0, max(n - frag_len, 1)))
+    frag = audio[frag_start:frag_start + frag_len]
+    # Replace random sections with repeated fragment
+    n_glitches = int(rng.integers(5, 30))
+    for _ in range(n_glitches):
+        pos = int(rng.integers(0, max(n - frag_len, 1)))
+        repeats = int(rng.integers(2, 10))
+        for r in range(repeats):
+            start = pos + r * frag_len
+            end = min(start + frag_len, n)
+            if start >= n:
+                break
+            audio[start:end] = frag[:end - start]
+    return audio, _pick(rng, ["glitchy", "stuttering", "broken", "digital"]), \
+        f"glitchy, stuttering repeating fragment of {desc}"
+
+
+@register(600, "editing")
+def gen_beat_repeat(rng):
+    dur = _dur(rng, 3, 15)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    # Pick a beat-length slice and repeat
+    beat_len = int(rng.uniform(0.1, 0.5) * SR)
+    slice_start = int(rng.integers(0, max(n - beat_len, 1)))
+    beat_slice = audio[slice_start:slice_start + beat_len]
+    # Repeat in a rhythmic pattern
+    out = np.zeros(n)
+    pos = 0
+    while pos < n:
+        if rng.random() < 0.6:  # 60% chance to play the repeated slice
+            end = min(pos + beat_len, n)
+            out[pos:end] = beat_slice[:end - pos]
+        else:
+            end = min(pos + beat_len, n)
+            out[pos:end] = audio[pos:end]
+        pos += beat_len
+    return out, _pick(rng, ["rhythmic", "repetitive", "chopped"]), \
+        f"rhythmic beat-repeat slice of {desc}"
+
+
+@register(600, "editing")
+def gen_freeze(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Short source
+    src_dur = min(rng.uniform(0.5, 2), dur)
+    src_n = _ns(src_dur)
+    src, src_desc, _ = _random_source(rng, src_n)
+    frame_size = 2048
+    freeze_pos = int(rng.integers(0, max(src_n - frame_size, 1)))
+    frame = src[freeze_pos:freeze_pos + frame_size]
+    mag = np.abs(np.fft.rfft(frame))
+    # Resynthesize with slowly evolving random phase
+    hop = frame_size // 4
+    n_frames = n // hop + 1
+    audio = np.zeros(n + frame_size)
+    window = np.hanning(frame_size)
+    for i in range(n_frames):
+        phase = rng.uniform(-np.pi, np.pi, len(mag))
+        spectrum = mag * np.exp(1j * phase)
+        frame_out = np.fft.irfft(spectrum, frame_size) * window
+        pos = i * hop
+        if pos + frame_size <= len(audio):
+            audio[pos:pos + frame_size] += frame_out
+    audio = audio[:n]
+    return audio, _pick(rng, ["frozen", "sustained", "static", "shimmering"]), \
+        f"frozen spectral slice of {src_desc}"
+
+
+@register(500, "editing")
+def gen_spectral_blur(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    # Spectral blur: smooth magnitudes, randomize phase
+    fft = np.fft.rfft(audio)
+    mag = np.abs(fft)
+    kernel_size = int(rng.integers(5, 50))
+    kernel = np.ones(kernel_size) / kernel_size
+    mag_smooth = np.convolve(mag, kernel, mode='same')
+    phase = rng.uniform(-np.pi, np.pi, len(fft))
+    blurred = mag_smooth * np.exp(1j * phase)
+    audio = np.fft.irfft(blurred, n)
+    return audio, _pick(rng, ["blurred", "smeared", "hazy", "diffuse"]), \
+        f"spectrally blurred {desc}"
+
+
+@register(600, "editing")
+def gen_vocoder(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Carrier
+    carrier_type = str(rng.choice(["noise", "sawtooth"]))
+    if carrier_type == "noise":
+        carrier = rng.standard_normal(n)
+        c_desc = "noise carrier"
+    else:
+        freq = _log_uniform(rng, 80, 400)
+        carrier = sig.sawtooth(2 * np.pi * freq * _t(n))
+        c_desc = f"sawtooth carrier at {_freq_str(freq)}"
+    # Modulator
+    mod_freq = _log_uniform(rng, 100, 1000)
+    t = _t(n)
+    modulator = np.sin(2 * np.pi * mod_freq * t)
+    m_desc = f"tonal modulator at {_freq_str(mod_freq)}"
+    # Vocoder bands
+    n_bands = int(rng.integers(8, 24))
+    audio = np.zeros(n)
+    band_freqs = np.logspace(np.log10(100), np.log10(10000), n_bands + 1)
+    for i in range(n_bands):
+        f_lo, f_hi = band_freqs[i], band_freqs[i + 1]
+        if f_hi > SR / 2 - 100:
+            break
+        sos = _safe_butter(3, [max(f_lo, 20), min(f_hi, SR / 2 - 100)], 'band')
+        if sos is None:
+            continue
+        mod_band = _apply_sos(modulator, sos)
+        car_band = _apply_sos(carrier, sos)
+        env = np.abs(sig.hilbert(mod_band))
+        smooth = _safe_butter(2, 50, 'low')
+        if smooth is not None:
+            env = _apply_sos(env, smooth)
+        audio += car_band * env
+    return audio, _pick(rng, ["robotic", "vocoded", "processed", "synthetic"]), \
+        f"vocoder effect with {c_desc} and {m_desc}"
+
+
+@register(400, "editing")
+def gen_time_stretch(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Generate short source, stretch to fill duration
+    src_dur = rng.uniform(0.5, 2)
+    src_n = _ns(src_dur)
+    src, src_desc, _ = _random_base(rng, src_n, allow_noise=False)
+    # Granular time stretch
+    grain_size = int(rng.uniform(0.02, 0.08) * SR)
+    window = np.hanning(grain_size)
+    hop_out = grain_size // 2
+    stretch_ratio = dur / src_dur
+    hop_in = max(int(hop_out / stretch_ratio), 1)
+    audio = np.zeros(n + grain_size)
+    src_pos = 0
+    out_pos = 0
+    while out_pos < n:
+        si = int(src_pos) % max(src_n - grain_size, 1)
+        end_s = min(si + grain_size, src_n)
+        gl = end_s - si
+        end_o = min(out_pos + gl, n + grain_size)
+        ol = end_o - out_pos
+        gl = min(gl, ol)
+        audio[out_pos:out_pos + gl] += src[si:si + gl] * window[:gl]
+        src_pos += hop_in
+        out_pos += hop_out
+    audio = audio[:n]
+    return audio, _pick(rng, ["stretched", "granular", "smeared"]), \
+        f"granular time-stretched {src_desc}"
+
+
+@register(400, "editing")
+def gen_varispeed(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Generate at different speed, resample to fill duration
+    speed = rng.uniform(0.3, 0.8)  # slow down
+    src_n = int(n * speed)
+    src, src_desc, _ = _random_base(rng, src_n, allow_noise=False)
+    # Resample to fill n samples (changes both speed and pitch)
+    audio = sig.resample(src, n)
+    desc = "slowed-down" if speed < 1 else "sped-up"
+    return audio, _pick(rng, ["pitched", "warped", desc]), \
+        f"{desc} {src_desc} shifting both speed and pitch"
+
+
+@register(500, "editing")
+def gen_chop_gate(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    # Rhythmic chopping
+    chop_rate = rng.uniform(4, 16)  # chops per second
+    chop_samples = max(int(SR / chop_rate), 10)
+    gate_ratio = rng.uniform(0.3, 0.7)
+    on_samples = int(chop_samples * gate_ratio)
+    env = np.zeros(n)
+    for pos in range(0, n, chop_samples):
+        end = min(pos + on_samples, n)
+        env[pos:end] = 1.0
+    # Smooth edges
+    sm = int(0.003 * SR)
+    if sm > 1:
+        kernel = np.ones(sm) / sm
+        env = np.convolve(env, kernel, mode='same')
+    audio *= env
+    return audio, _pick(rng, ["choppy", "rhythmic", "gated", "stuttering"]), \
+        f"rhythmically chopped and gated {desc}"

generator/generators/filters.py

@@ -0,0 +1,227 @@
+"""Category F: Filters & Tone Shaping — 8,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _wave, _freq_str,
+                   _random_base, _pick, _safe_butter, _apply_sos,
+                   _peaking_eq, _shelf_eq)
+from constants import (LOW_DESCS, HIGH_DESCS, BUZZ_DESCS, METAL_DESCS,
+                        CLEAN_DESCS, VOWEL_FORMANTS)
+
+
+@register(800, "filters")
+def gen_lowpass(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    cutoff = _log_uniform(rng, 200, 5000)
+    sos = _safe_butter(4, cutoff, 'low')
+    audio = _apply_sos(audio, sos)
+    return audio, _pick(rng, LOW_DESCS), \
+        f"{desc} filtered with low-pass at {_freq_str(cutoff)}"
+
+
+@register(800, "filters")
+def gen_highpass(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    cutoff = _log_uniform(rng, 500, 10000)
+    sos = _safe_butter(4, cutoff, 'high')
+    audio = _apply_sos(audio, sos)
+    return audio, _pick(rng, HIGH_DESCS), \
+        f"{desc} filtered with high-pass at {_freq_str(cutoff)}"
+
+
+@register(800, "filters")
+def gen_bandpass(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    center = _log_uniform(rng, 300, 8000)
+    Q = rng.uniform(1, 10)
+    bw = center / Q
+    sos = _safe_butter(4, [max(center - bw / 2, 20), min(center + bw / 2, SR / 2 - 100)], 'band')
+    audio = _apply_sos(audio, sos)
+    return audio, _pick(rng, BUZZ_DESCS + ["nasal", "focused"]), \
+        f"bandpass-filtered {desc} at {_freq_str(center)}"
+
+
+@register(500, "filters")
+def gen_notch(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    freq = _log_uniform(rng, 200, 8000)
+    Q = rng.uniform(10, 50)
+    try:
+        b, a = sig.iirnotch(freq, Q, SR)
+        audio = sig.lfilter(b, a, audio)
+    except Exception:
+        pass
+    return audio, _pick(rng, CLEAN_DESCS), \
+        f"{desc} with a notch filter removing {_freq_str(freq)}"
+
+
+@register(500, "filters")
+def gen_peaking_eq(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    freq = _log_uniform(rng, 200, 8000)
+    gain = rng.uniform(6, 18)
+    Q = rng.uniform(1, 5)
+    try:
+        b, a = _peaking_eq(freq, gain, Q)
+        audio = sig.lfilter(b, a, audio)
+    except Exception:
+        pass
+    return audio, _pick(rng, HIGH_DESCS + ["resonant", "boosted"]), \
+        f"{desc} with {gain:.0f} dB peaking EQ boost at {_freq_str(freq)}"
+
+
+@register(500, "filters")
+def gen_shelf_eq(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    shelf_type = str(rng.choice(["high", "low"]))
+    freq = _log_uniform(rng, 500, 5000)
+    gain = rng.uniform(-12, -3)  # cut
+    try:
+        b, a = _shelf_eq(freq, gain, shelf_type)
+        audio = sig.lfilter(b, a, audio)
+    except Exception:
+        pass
+    char = "dark" if shelf_type == "high" else "thin"
+    return audio, _pick(rng, [char, "shaped", "sculpted"]), \
+        f"{desc} with {shelf_type}-shelf cut giving a {char} character"
+
+
+@register(600, "filters")
+def gen_comb_filter(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    delay_ms = rng.uniform(0.5, 10)
+    delay_samples = max(int(delay_ms * SR / 1000), 1)
+    feedback = rng.uniform(0.3, 0.8)
+    out = audio.copy()
+    out[delay_samples:] += feedback * audio[:-delay_samples]
+    return out, _pick(rng, METAL_DESCS + ["flanged", "hollow"]), \
+        f"comb-filtered {desc}"
+
+
+@register(500, "filters")
+def gen_allpass(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    n_stages = int(rng.integers(4, 12))
+    for _ in range(n_stages):
+        freq = _log_uniform(rng, 200, 8000)
+        Q = rng.uniform(0.5, 5)
+        try:
+            b, a = sig.iirpeak(min(freq, SR / 2 - 100), Q, SR)
+            # allpass = 2*bandpass - input
+            bp = sig.lfilter(b, a, audio)
+            audio = 2 * bp - audio
+        except Exception:
+            pass
+    return audio, _pick(rng, ["phaser-like", "swirling", "colored"]), \
+        f"cascade of allpass filters creating phaser-like coloring on {desc}"
+
+
+@register(800, "filters")
+def gen_formant_vowel(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 50, 400)
+    t = _t(n)
+    audio = sig.sawtooth(2 * np.pi * freq * t)
+    vowel = str(rng.choice(list(VOWEL_FORMANTS.keys())))
+    formants = VOWEL_FORMANTS[vowel]
+    filtered = np.zeros(n)
+    for fc, bw in formants:
+        f_lo = max(fc - bw, 20)
+        f_hi = min(fc + bw, SR / 2 - 100)
+        if f_lo >= f_hi:
+            continue
+        sos = _safe_butter(2, [f_lo, f_hi], 'band')
+        if sos is not None:
+            filtered += _apply_sos(audio, sos)
+    if np.max(np.abs(filtered)) > 1e-10:
+        audio = filtered
+    return audio, _pick(rng, BUZZ_DESCS + ["vocal", "resonant"]), \
+        f"sawtooth shaped into an '{vowel}' vowel formant"
+
+
+@register(1000, "filters")
+def gen_filter_sweep(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    ftype = str(rng.choice(["lowpass", "highpass"]))
+    f_start = _log_uniform(rng, 200, 8000)
+    f_end = _log_uniform(rng, 200, 8000)
+    # Process in blocks with changing filter
+    block_size = 1024
+    freqs = np.geomspace(f_start, f_end, n // block_size + 1)
+    out = np.zeros(n)
+    btype = 'low' if ftype == "lowpass" else 'high'
+    for i in range(0, n, block_size):
+        end = min(i + block_size, n)
+        f = float(np.clip(freqs[i // block_size], 20, SR / 2 - 100))
+        sos = _safe_butter(2, f, btype)
+        if sos is not None:
+            out[i:end] = _apply_sos(audio[i:end], sos)
+        else:
+            out[i:end] = audio[i:end]
+    direction = "opening" if (ftype == "lowpass" and f_end > f_start) or \
+                              (ftype == "highpass" and f_end < f_start) else "closing"
+    pool = HIGH_DESCS if ftype == "highpass" else LOW_DESCS
+    return out, _pick(rng, pool + ["sweeping", "resonant"]), \
+        f"{direction} {ftype.replace('pass', '-pass')} filter sweep on {desc}"
+
+
+@register(700, "filters")
+def gen_wah(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    rate = rng.uniform(1, 8)
+    center = _log_uniform(rng, 500, 3000)
+    t = _t(n)
+    # Auto-wah via STFT
+    nperseg = 1024
+    f, t_stft, Zxx = sig.stft(audio, fs=SR, nperseg=nperseg)
+    lfo = np.sin(2 * np.pi * rate * t)
+    for i in range(Zxx.shape[1]):
+        t_pos = t_stft[i] if i < len(t_stft) else t_stft[-1]
+        idx = min(int(t_pos * SR), n - 1)
+        cf = center * 2 ** (lfo[idx] * 1.5)
+        Q = 5
+        filt = np.exp(-0.5 * ((f - cf) / (cf / Q + 1)) ** 2)
+        Zxx[:, i] *= filt
+    _, out = sig.istft(Zxx, fs=SR, nperseg=nperseg)
+    out = out[:n] if len(out) >= n else np.pad(out, (0, n - len(out)))
+    return out, _pick(rng, ["funky", "expressive", "quacky"]), \
+        f"auto-wah envelope filter on {desc}"
+
+
+@register(500, "filters")
+def gen_resonance(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    freq = _log_uniform(rng, 200, 5000)
+    Q = rng.uniform(10, 50)
+    try:
+        b, a = sig.iirpeak(min(freq, SR / 2 - 100), Q, SR)
+        audio = sig.lfilter(b, a, audio)
+    except Exception:
+        pass
+    return audio, _pick(rng, ["resonant", "ringing", "peaky"]), \
+        f"highly resonant bandpass filter at {_freq_str(freq)} on {desc}"

generator/generators/modulation.py

@@ -0,0 +1,152 @@
+"""Category J: Modulation Effects — 5,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _wave, _freq_str,
+                   _random_base, _pick, _chorus, _flanger, _safe_butter,
+                   _apply_sos, _normalize)
+from constants import CLEAN_DESCS, SOFT_DESCS, METAL_DESCS
+
+
+@register(700, "modulation")
+def gen_chorus(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    audio = _chorus(audio, rng)
+    return audio, _pick(rng, ["warm", "lush", "wide", "shimmering"]), \
+        f"chorus effect on {desc}"
+
+
+@register(700, "modulation")
+def gen_flanger(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    audio = _flanger(audio, rng)
+    return audio, _pick(rng, ["jet-like", "whooshing", "sweeping", "metallic"]), \
+        f"flanger sweep on {desc}"
+
+
+@register(700, "modulation")
+def gen_phaser(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    rate = rng.uniform(0.1, 2)
+    n_stages = int(rng.integers(4, 8))
+    t = _t(n)
+    lfo = np.sin(2 * np.pi * rate * t)
+    # Cascade of modulated allpass filters
+    for stage in range(n_stages):
+        center = _log_uniform(rng, 200, 4000)
+        depth = rng.uniform(0.3, 0.8)
+        delay_mod = (center * (1 + depth * lfo)).astype(int)
+        delay_mod = np.clip(delay_mod, 1, n - 1)
+        indices = np.clip(np.arange(n) - delay_mod // 100, 0, n - 1)
+        delayed = audio[indices]
+        fb = rng.uniform(0.3, 0.7)
+        audio = audio + fb * delayed
+    audio = _normalize(audio)
+    return audio, _pick(rng, ["swirling", "phasing", "spacey", "psychedelic"]), \
+        f"phaser on {desc}"
+
+
+@register(700, "modulation")
+def gen_tremolo(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 100, 2000)
+    trem_rate = rng.uniform(3, 15)
+    depth = rng.uniform(0.5, 1.0)
+    t = _t(n)
+    audio = np.sin(2 * np.pi * freq * t)
+    trem = 1.0 - depth * 0.5 * (1 + np.sin(2 * np.pi * trem_rate * t))
+    audio *= trem
+    depth_str = "deep" if depth > 0.7 else "subtle"
+    return audio, _pick(rng, ["pulsing", "throbbing", depth_str]), \
+        f"{_freq_str(freq)} sine with {depth_str} tremolo at {trem_rate:.0f} Hz"
+
+
+@register(500, "modulation")
+def gen_autopan(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    rate = rng.uniform(0.5, 5)
+    t = _t(n)
+    # Simulated as amplitude oscillation (mono representation of panning)
+    pan = 0.5 + 0.4 * np.sin(2 * np.pi * rate * t)
+    audio *= pan
+    return audio, _pick(rng, ["sweeping", "moving", "spatial"]), \
+        f"auto-panning {desc} sweeping left and right"
+
+
+@register(500, "modulation")
+def gen_rotary(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Organ-like source (additive harmonics)
+    freq = _log_uniform(rng, 100, 500)
+    t = _t(n)
+    audio = np.zeros(n)
+    for h in [1, 2, 3, 4, 6, 8]:
+        f = freq * h
+        if f > SR / 2:
+            break
+        audio += (1.0 / h) * np.sin(2 * np.pi * f * t)
+    # Leslie effect: amplitude + frequency modulation
+    slow_rate = rng.uniform(0.5, 2)  # slow speed
+    fast_rate = rng.uniform(5, 8)     # fast speed
+    rate = rng.choice([slow_rate, fast_rate])
+    am = 0.5 + 0.3 * np.sin(2 * np.pi * rate * t)
+    fm_depth = rng.uniform(0.001, 0.005)
+    fm_mod = fm_depth * np.sin(2 * np.pi * rate * t)
+    delay = (fm_mod * SR).astype(int)
+    indices = np.clip(np.arange(n) - delay, 0, n - 1)
+    audio = audio[indices] * am
+    return audio, _pick(rng, ["swirling", "warm", "rotating", "vintage"]), \
+        "Leslie rotary speaker effect on an organ-like tone"
+
+
+@register(600, "modulation")
+def gen_freq_shifter(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 100, 2000)
+    shift = rng.uniform(1, 50)
+    t = _t(n)
+    audio = np.sin(2 * np.pi * freq * t)
+    # Frequency shifting via multiplication with complex exponential
+    shifted = audio * np.cos(2 * np.pi * shift * t)
+    audio = 0.5 * audio + 0.5 * shifted
+    return audio, _pick(rng, ["inharmonic", "metallic", "alien", "dissonant"]), \
+        f"frequency-shifted {_freq_str(freq)} sine creating inharmonic overtones"
+
+
+@register(600, "modulation")
+def gen_lfo_filter(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n)
+    lfo_rate = rng.uniform(0.1, 2)
+    center = _log_uniform(rng, 500, 5000)
+    # Block processing with LFO-modulated filter
+    block_size = 512
+    t = _t(n)
+    lfo = np.sin(2 * np.pi * lfo_rate * t)
+    out = np.zeros(n)
+    for i in range(0, n, block_size):
+        end = min(i + block_size, n)
+        idx = min(i, n - 1)
+        f = center * 2 ** (lfo[idx] * 1.5)
+        f = float(np.clip(f, 20, SR / 2 - 100))
+        sos = _safe_butter(2, f, 'low')
+        if sos is not None:
+            out[i:end] = _apply_sos(audio[i:end], sos)
+        else:
+            out[i:end] = audio[i:end]
+    return out, _pick(rng, ["sweeping", "evolving", "modulated"]), \
+        f"slowly LFO-modulated filter cutoff on {desc}"

generator/generators/musical.py

@@ -0,0 +1,204 @@
+"""Category D: Musical Constructs — 10,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _wave, _freq_str,
+                   _midi_to_freq, _midi_to_name, _random_midi, _pick, _adsr)
+from constants import (CHORD_TYPES, SCALE_TYPES, INTERVAL_NAMES, DTMF_FREQS,
+                        NOTE_NAMES, LOW_DESCS, HIGH_DESCS, CLEAN_DESCS, SOFT_DESCS)
+
+
+@register(2500, "musical_constructs")
+def gen_chord(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    root = _random_midi(rng, 36, 72)
+    chord_name = str(rng.choice(list(CHORD_TYPES.keys())))
+    intervals = CHORD_TYPES[chord_name]
+    wtype = str(rng.choice(["sine", "sawtooth", "square", "triangle"]))
+    t = _t(n)
+    audio = np.zeros(n)
+    for iv in intervals:
+        audio += _wave(wtype, _midi_to_freq(root + iv), t)
+    audio /= len(intervals)
+    env = _adsr(dur, attack=rng.uniform(0.005, 0.1), decay=rng.uniform(0.05, 0.3),
+                sustain=rng.uniform(0.5, 0.9), release=rng.uniform(0.1, 0.5))
+    audio *= env
+    root_name = _midi_to_name(root)
+    note_letter = NOTE_NAMES[root % 12]
+    return audio, _pick(rng, SOFT_DESCS + CLEAN_DESCS), \
+        f"{note_letter} {chord_name} chord played with {wtype} waves"
+
+
+@register(1500, "musical_constructs")
+def gen_arpeggio(rng):
+    dur = _dur(rng, 3, 20)
+    n = _ns(dur)
+    root = _random_midi(rng, 48, 72)
+    chord_name = str(rng.choice(list(CHORD_TYPES.keys())))
+    intervals = CHORD_TYPES[chord_name]
+    notes_per_sec = rng.uniform(3, 12)
+    direction = str(rng.choice(["ascending", "descending", "alternating"]))
+    wtype = str(rng.choice(["sine", "sawtooth", "triangle"]))
+    note_dur = 1.0 / notes_per_sec
+    note_samples = int(note_dur * SR)
+    t_note = _t(note_samples)
+    env = np.exp(-t_note * rng.uniform(3, 15))
+    audio = np.zeros(n)
+    note_list = list(intervals)
+    if direction == "descending":
+        note_list = list(reversed(note_list))
+    elif direction == "alternating":
+        note_list = list(intervals) + list(reversed(intervals[1:-1]))
+    if not note_list:
+        note_list = list(intervals)
+    idx = 0
+    pos = 0
+    while pos < n:
+        iv = note_list[idx % len(note_list)]
+        freq = _midi_to_freq(root + iv)
+        end = min(pos + note_samples, n)
+        sl = end - pos
+        audio[pos:end] += _wave(wtype, freq, t_note[:sl]) * env[:sl]
+        pos += note_samples
+        idx += 1
+    note_letter = NOTE_NAMES[root % 12]
+    return audio, _pick(rng, HIGH_DESCS + CLEAN_DESCS), \
+        f"{direction} {note_letter} {chord_name} arpeggio at {notes_per_sec:.0f} notes per second"
+
+
+@register(1500, "musical_constructs")
+def gen_scale(rng):
+    dur = _dur(rng, 3, 15)
+    n = _ns(dur)
+    root = _random_midi(rng, 48, 72)
+    scale_name = str(rng.choice(list(SCALE_TYPES.keys())))
+    degrees = SCALE_TYPES[scale_name]
+    direction = str(rng.choice(["ascending", "descending"]))
+    wtype = str(rng.choice(["sine", "sawtooth", "triangle"]))
+    note_list = [root + d for d in degrees]
+    if direction == "ascending":
+        note_list.append(root + 12)
+    else:
+        note_list = list(reversed(note_list))
+        note_list.insert(0, root + 12)
+    note_dur = dur / len(note_list)
+    note_samples = int(note_dur * SR)
+    t_note = _t(note_samples)
+    env = _adsr(note_dur, 0.005, 0.02, 0.8, 0.05)[:note_samples]
+    audio = np.zeros(n)
+    for i, midi in enumerate(note_list):
+        pos = i * note_samples
+        end = min(pos + note_samples, n)
+        sl = end - pos
+        audio[pos:end] += _wave(wtype, _midi_to_freq(midi), t_note[:sl]) * env[:sl]
+    note_letter = NOTE_NAMES[root % 12]
+    return audio, _pick(rng, CLEAN_DESCS), \
+        f"{direction} {note_letter} {scale_name} scale"
+
+
+@register(1000, "musical_constructs")
+def gen_interval(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    root = _random_midi(rng, 48, 76)
+    semitones = int(rng.choice(list(INTERVAL_NAMES.keys())))
+    if semitones == 0:
+        semitones = 7  # default to fifth
+    interval_name = INTERVAL_NAMES.get(semitones, f"{semitones} semitones")
+    simultaneous = rng.random() > 0.3
+    wtype = str(rng.choice(["sine", "sawtooth", "triangle"]))
+    t = _t(n)
+    f1 = _midi_to_freq(root)
+    f2 = _midi_to_freq(root + semitones)
+    if simultaneous:
+        audio = 0.5 * (_wave(wtype, f1, t) + _wave(wtype, f2, t))
+        play_str = "played simultaneously"
+    else:
+        half = n // 2
+        audio = np.zeros(n)
+        audio[:half] = _wave(wtype, f1, t[:half])
+        audio[half:] = _wave(wtype, f2, t[:n - half])
+        play_str = "played sequentially"
+    return audio, _pick(rng, CLEAN_DESCS), \
+        f"{interval_name} interval from {_midi_to_name(root)}, {play_str}"
+
+
+@register(1500, "musical_constructs")
+def gen_melody(rng):
+    dur = _dur(rng, 4, 20)
+    n = _ns(dur)
+    root = _random_midi(rng, 48, 72)
+    scale_name = str(rng.choice(list(SCALE_TYPES.keys())))
+    degrees = SCALE_TYPES[scale_name]
+    bpm = rng.uniform(60, 180)
+    wtype = str(rng.choice(["sine", "sawtooth", "square", "triangle"]))
+    beat_samples = int(SR * 60 / bpm)
+    # Generate random note sequence from scale
+    n_notes = max(int(dur * bpm / 60), 4)
+    available = []
+    for octave_shift in [-12, 0, 12]:
+        for d in degrees:
+            available.append(root + d + octave_shift)
+    notes = [int(rng.choice(available)) for _ in range(n_notes)]
+    t_note = _t(beat_samples)
+    env = _adsr(beat_samples / SR, 0.005, 0.05, 0.6, 0.05)[:beat_samples]
+    audio = np.zeros(n)
+    for i, midi in enumerate(notes):
+        pos = i * beat_samples
+        end = min(pos + beat_samples, n)
+        sl = end - pos
+        freq = _midi_to_freq(midi)
+        audio[pos:end] += _wave(wtype, freq, t_note[:sl]) * env[:sl]
+    note_letter = NOTE_NAMES[root % 12]
+    return audio, _pick(rng, CLEAN_DESCS + ["playful", "melodic"]), \
+        f"random melody in {note_letter} {scale_name} at {bpm:.0f} BPM"
+
+
+@register(1000, "musical_constructs")
+def gen_harmonic_series(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    fundamental = _log_uniform(rng, 50, 500)
+    n_harmonics = int(rng.integers(4, 16))
+    t = _t(n)
+    audio = np.zeros(n)
+    rolloff = rng.uniform(0.5, 2.0)
+    for h in range(1, n_harmonics + 1):
+        f = fundamental * h
+        if f > SR / 2:
+            break
+        amp = 1.0 / h ** rolloff
+        audio += amp * np.sin(2 * np.pi * f * t)
+    return audio, _pick(rng, CLEAN_DESCS + ["rich", "harmonic"]), \
+        f"overtone series on {_freq_str(fundamental)} with {n_harmonics} harmonics"
+
+
+@register(500, "musical_constructs")
+def gen_dtmf(rng):
+    dur = _dur(rng, 2, 8)
+    n = _ns(dur)
+    digits = list("0123456789")
+    length = int(rng.integers(3, 10))
+    sequence = "".join(str(rng.choice(digits)) for _ in range(length))
+    tone_dur = min(0.2, dur / (length * 2))
+    pause_dur = tone_dur * 0.5
+    tone_samples = int(tone_dur * SR)
+    pause_samples = int(pause_dur * SR)
+    audio = np.zeros(n)
+    pos = 0
+    for digit in sequence:
+        if digit in DTMF_FREQS and pos + tone_samples < n:
+            f1, f2 = DTMF_FREQS[digit]
+            t = _t(tone_samples)
+            tone = 0.5 * (np.sin(2 * np.pi * f1 * t) + np.sin(2 * np.pi * f2 * t))
+            # Apply short envelope
+            env_len = min(int(0.005 * SR), tone_samples // 4)
+            tone[:env_len] *= np.linspace(0, 1, env_len)
+            tone[-env_len:] *= np.linspace(1, 0, env_len)
+            audio[pos:pos + tone_samples] = tone
+            pos += tone_samples + pause_samples
+    return audio, _pick(rng, ["electronic", "digital"]), \
+        f"DTMF tones dialing the sequence {sequence}"

generator/generators/noise.py

@@ -0,0 +1,121 @@
+"""Category B: Noise Types — 6,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _freq_str, _pick,
+                   _pink_noise, _brown_noise, _blue_noise, _violet_noise,
+                   _grey_noise, _safe_butter, _apply_sos)
+from constants import LOW_DESCS, HIGH_DESCS, CLEAN_DESCS, SOFT_DESCS
+
+
+@register(800, "noise")
+def gen_white_noise(rng):
+    dur = _dur(rng)
+    audio = rng.standard_normal(_ns(dur))
+    return audio, _pick(rng, CLEAN_DESCS + ["broadband", "hissy"]), "white noise"
+
+
+@register(800, "noise")
+def gen_pink_noise(rng):
+    dur = _dur(rng)
+    audio = _pink_noise(rng, _ns(dur))
+    return audio, _pick(rng, SOFT_DESCS + ["natural"]), "pink noise"
+
+
+@register(800, "noise")
+def gen_brown_noise(rng):
+    dur = _dur(rng)
+    audio = _brown_noise(rng, _ns(dur))
+    return audio, _pick(rng, LOW_DESCS + ["rumbling"]), "brown noise"
+
+
+@register(500, "noise")
+def gen_blue_noise(rng):
+    dur = _dur(rng)
+    audio = _blue_noise(rng, _ns(dur))
+    return audio, _pick(rng, HIGH_DESCS), "blue noise"
+
+
+@register(500, "noise")
+def gen_violet_noise(rng):
+    dur = _dur(rng)
+    audio = _violet_noise(rng, _ns(dur))
+    return audio, _pick(rng, HIGH_DESCS + ["harsh"]), "violet noise"
+
+
+@register(400, "noise")
+def gen_grey_noise(rng):
+    dur = _dur(rng)
+    audio = _grey_noise(rng, _ns(dur))
+    return audio, _pick(rng, ["balanced", "even", "flat"]), \
+        "grey noise with perceptually flat loudness"
+
+
+@register(600, "noise")
+def gen_vinyl_crackle(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Background hiss
+    hiss = rng.standard_normal(n) * 0.05
+    sos = _safe_butter(2, 2000, 'low')
+    if sos is not None:
+        hiss = _apply_sos(hiss, sos)
+    # Random crackles
+    n_crackles = int(rng.uniform(5, 50) * dur)
+    for _ in range(n_crackles):
+        pos = rng.integers(0, n)
+        length = int(rng.uniform(0.0001, 0.002) * SR)
+        end = min(pos + length, n)
+        hiss[pos:end] += rng.uniform(0.3, 1.0) * rng.choice([-1, 1]) * \
+            np.exp(-np.arange(end - pos) / (0.0005 * SR))
+    return hiss, _pick(rng, ["warm", "vintage", "nostalgic"]), \
+        "vinyl crackle and surface noise"
+
+
+@register(600, "noise")
+def gen_tape_hiss(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    noise = rng.standard_normal(n)
+    # Tape hiss is mostly high-frequency
+    sos = _safe_butter(3, rng.uniform(3000, 8000), 'high')
+    if sos is not None:
+        noise = _apply_sos(noise, sos)
+    # Slight low-pass to remove harshest highs
+    sos2 = _safe_butter(2, rng.uniform(12000, 18000), 'low')
+    if sos2 is not None:
+        noise = _apply_sos(noise, sos2)
+    return noise, _pick(rng, ["warm", "analog", "soft", "gentle"]), \
+        "analog tape hiss"
+
+
+@register(1000, "noise")
+def gen_filtered_noise(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Pick noise type
+    noise_type = str(rng.choice(["white", "pink"]))
+    if noise_type == "white":
+        audio = rng.standard_normal(n)
+    else:
+        audio = _pink_noise(rng, n)
+    # Pick filter type
+    ftype = str(rng.choice(["lowpass", "highpass", "bandpass"]))
+    freq = _log_uniform(rng, 200, 8000)
+    Q = rng.uniform(0.5, 10)
+    if ftype == "bandpass":
+        bw = freq / Q
+        sos = _safe_butter(4, [max(freq - bw / 2, 20), min(freq + bw / 2, SR / 2 - 100)], 'band')
+        filter_desc = f"resonant bandpass at {_freq_str(freq)}"
+    elif ftype == "lowpass":
+        sos = _safe_butter(4, freq, 'low')
+        filter_desc = f"low-pass filter at {_freq_str(freq)}"
+    else:
+        sos = _safe_butter(4, freq, 'high')
+        filter_desc = f"high-pass filter at {_freq_str(freq)}"
+    if sos is not None:
+        audio = _apply_sos(audio, sos)
+    descs = LOW_DESCS if ftype == "lowpass" else HIGH_DESCS if ftype == "highpass" else []
+    return audio, _pick(rng, descs), f"{noise_type} noise through a {filter_desc}"

generator/generators/percussive.py

@@ -0,0 +1,162 @@
+"""Category K: Percussive & Transient — 8,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _pick,
+                   _make_kick, _make_snare, _make_hihat,
+                   _safe_butter, _apply_sos, _normalize)
+from constants import DRUM_PATTERNS, LOW_DESCS, HIGH_DESCS, METAL_DESCS
+
+
+@register(1500, "percussive")
+def gen_kick(rng):
+    dur = _dur(rng, 2, 10)
+    n = _ns(dur)
+    hit_n = min(int(0.5 * SR), n)
+    hit = _make_kick(rng, hit_n)
+    audio = np.zeros(n)
+    # Place kicks periodically or as single hit
+    n_hits = int(rng.integers(1, max(int(dur * 3), 2)))
+    spacing = n // n_hits
+    for i in range(n_hits):
+        pos = i * spacing
+        end = min(pos + hit_n, n)
+        audio[pos:end] += hit[:end - pos]
+    return audio, _pick(rng, ["deep", "punchy", "boomy", "thumping"]), \
+        "synthesized kick drum"
+
+
+@register(1500, "percussive")
+def gen_snare(rng):
+    dur = _dur(rng, 2, 10)
+    n = _ns(dur)
+    hit_n = min(int(0.3 * SR), n)
+    hit = _make_snare(rng, hit_n)
+    audio = np.zeros(n)
+    n_hits = int(rng.integers(1, max(int(dur * 3), 2)))
+    spacing = n // n_hits
+    for i in range(n_hits):
+        pos = i * spacing
+        end = min(pos + hit_n, n)
+        audio[pos:end] += hit[:end - pos]
+    return audio, _pick(rng, ["crisp", "snappy", "bright", "cracking"]), \
+        "synthesized snare drum"
+
+
+@register(1000, "percussive")
+def gen_hihat(rng):
+    dur = _dur(rng, 2, 10)
+    n = _ns(dur)
+    open_close = str(rng.choice(["closed", "open"]))
+    hit_n = int(0.05 * SR) if open_close == "closed" else int(0.3 * SR)
+    hit_n = min(hit_n, n)
+    hit = _make_hihat(rng, hit_n)
+    audio = np.zeros(n)
+    rate = rng.uniform(4, 16)
+    spacing = max(int(SR / rate), hit_n)
+    for pos in range(0, n, spacing):
+        end = min(pos + hit_n, n)
+        audio[pos:end] += hit[:end - pos]
+    return audio, _pick(rng, METAL_DESCS[:2] + ["short", "sizzly"]), \
+        f"short, {open_close} hi-hat"
+
+
+@register(500, "percussive")
+def gen_click_pop(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    rate = rng.uniform(2, 20)
+    spacing = max(int(SR / rate), 10)
+    audio = np.zeros(n)
+    for pos in range(0, n, spacing):
+        click_type = str(rng.choice(["impulse", "short_burst"]))
+        if click_type == "impulse":
+            if pos < n:
+                audio[pos] = rng.uniform(0.5, 1.0) * float(rng.choice([-1, 1]))
+        else:
+            cl = min(int(rng.uniform(0.0001, 0.003) * SR), n - pos)
+            audio[pos:pos + cl] = rng.uniform(0.3, 0.8) * \
+                np.exp(-np.arange(cl) / (0.0005 * SR)) * float(rng.choice([-1, 1]))
+    return audio, _pick(rng, ["sharp", "digital", "staccato", "percussive"]), \
+        "series of sharp digital clicks"
+
+
+@register(500, "percussive")
+def gen_clap(rng):
+    dur = _dur(rng, 2, 10)
+    n = _ns(dur)
+    # Clap: multiple short noise bursts close together + reverb tail
+    clap_n = min(int(0.15 * SR), n)
+    clap = np.zeros(clap_n)
+    n_micro = int(rng.integers(3, 7))
+    for j in range(n_micro):
+        pos = int(j * rng.uniform(0.003, 0.01) * SR)
+        burst_len = min(int(rng.uniform(0.002, 0.008) * SR), clap_n - pos)
+        if pos + burst_len <= clap_n:
+            clap[pos:pos + burst_len] += rng.standard_normal(burst_len) * \
+                np.exp(-np.arange(burst_len) / (0.003 * SR))
+    # Filter: bandpass
+    sos = _safe_butter(3, [500, 5000], 'band')
+    if sos is not None:
+        clap = _apply_sos(clap, sos)
+    # Reverb tail
+    tail_n = min(int(0.1 * SR), clap_n)
+    tail = rng.standard_normal(tail_n) * np.exp(-np.arange(tail_n) / (0.03 * SR)) * 0.3
+    clap[-tail_n:] += tail
+    audio = np.zeros(n)
+    n_claps = int(rng.integers(1, max(int(dur * 2), 2)))
+    spacing = n // n_claps
+    for i in range(n_claps):
+        pos = i * spacing
+        end = min(pos + clap_n, n)
+        audio[pos:end] += clap[:end - pos]
+    return audio, _pick(rng, ["snappy", "layered", "tight"]), \
+        "layered synthesized handclap"
+
+
+@register(3000, "percussive")
+def gen_drum_pattern(rng):
+    dur = _dur(rng, 4, 20)
+    n = _ns(dur)
+    bpm = rng.uniform(80, 160)
+    pattern_name = str(rng.choice(list(DRUM_PATTERNS.keys())))
+    pattern = DRUM_PATTERNS[pattern_name]
+    # 16th note duration
+    step_dur = 60.0 / bpm / 4
+    step_samples = max(int(step_dur * SR), 1)
+    # Generate hits
+    kick_hit = _make_kick(rng, min(int(0.3 * SR), step_samples))
+    snare_hit = _make_snare(rng, min(int(0.2 * SR), step_samples))
+    hihat_hit = _make_hihat(rng, min(int(0.05 * SR), step_samples))
+    audio = np.zeros(n)
+    steps = pattern["kick"]
+    n_steps = len(steps)
+    pos = 0
+    step_idx = 0
+    while pos < n:
+        idx = step_idx % n_steps
+        if pattern["kick"][idx]:
+            end = min(pos + len(kick_hit), n)
+            audio[pos:end] += kick_hit[:end - pos] * 0.8
+        if pattern["snare"][idx]:
+            end = min(pos + len(snare_hit), n)
+            audio[pos:end] += snare_hit[:end - pos] * 0.6
+        if pattern["hihat"][idx]:
+            end = min(pos + len(hihat_hit), n)
+            audio[pos:end] += hihat_hit[:end - pos] * 0.3
+        pos += step_samples
+        step_idx += 1
+    audio = _normalize(audio)
+    instruments = []
+    if any(pattern["kick"]):
+        instruments.append("kick")
+    if any(pattern["snare"]):
+        instruments.append("snare")
+    if any(pattern["hihat"]):
+        instruments.append("hi-hat")
+    inst_str = ", ".join(instruments[:-1]) + f", and {instruments[-1]}" \
+        if len(instruments) > 2 else " and ".join(instruments)
+    return audio, _pick(rng, ["punchy", "groovy", "rhythmic", "driving"]), \
+        f"{bpm:.0f} BPM {pattern_name} drum pattern with {inst_str}"

generator/generators/pitch.py

@@ -0,0 +1,152 @@
+"""Category E: Pitch / Tuning Effects — 5,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _wave, _freq_str,
+                   _midi_to_freq, _midi_to_name, _random_midi, _pick,
+                   _safe_butter, _apply_sos)
+from constants import CLEAN_DESCS, LOW_DESCS, HIGH_DESCS, SOFT_DESCS
+
+
+@register(1000, "pitch_tuning")
+def gen_vibrato(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 100, 2000)
+    vib_rate = rng.uniform(3, 8)
+    vib_depth = rng.uniform(0.5, 3)  # semitones
+    t = _t(n)
+    mod = vib_depth * np.sin(2 * np.pi * vib_rate * t)
+    inst_freq = freq * 2 ** (mod / 12)
+    phase = np.cumsum(2 * np.pi * inst_freq / SR)
+    audio = np.sin(phase)
+    return audio, _pick(rng, SOFT_DESCS + ["expressive", "singing"]), \
+        f"{_freq_str(freq)} sine with vibrato at {vib_rate:.0f} Hz rate"
+
+
+@register(800, "pitch_tuning")
+def gen_pitch_bend(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 100, 2000)
+    bend_semitones = rng.uniform(2, 24)
+    direction = str(rng.choice(["up", "down"]))
+    t = _t(n)
+    if direction == "up":
+        bend = np.linspace(0, bend_semitones, n)
+    else:
+        bend = np.linspace(0, -bend_semitones, n)
+    inst_freq = freq * 2 ** (bend / 12)
+    phase = np.cumsum(2 * np.pi * inst_freq / SR)
+    audio = np.sin(phase)
+    desc = f"smooth pitch bend {direction}"
+    if bend_semitones >= 11:
+        desc += " one octave"
+    else:
+        desc += f" {bend_semitones:.0f} semitones"
+    return audio, _pick(rng, ["sweeping", "sliding"]), \
+        f"{_freq_str(freq)} tone with {desc}"
+
+
+@register(800, "pitch_tuning")
+def gen_glide(rng):
+    dur = _dur(rng, 2, 10)
+    n = _ns(dur)
+    midi1 = _random_midi(rng, 36, 72)
+    midi2 = _random_midi(rng, 36, 84)
+    while midi2 == midi1:
+        midi2 = _random_midi(rng, 36, 84)
+    wtype = str(rng.choice(["sine", "sawtooth", "square"]))
+    t = _t(n)
+    # Exponential glide
+    freq1 = _midi_to_freq(midi1)
+    freq2 = _midi_to_freq(midi2)
+    freq_env = freq1 * (freq2 / freq1) ** (t / (dur))
+    phase = np.cumsum(2 * np.pi * freq_env / SR)
+    if wtype == "sine":
+        audio = np.sin(phase)
+    elif wtype == "sawtooth":
+        audio = sig.sawtooth(phase)
+    else:
+        audio = sig.square(phase)
+    return audio, _pick(rng, ["smooth", "gliding", "sweeping"]), \
+        f"portamento glide from {_midi_to_name(midi1)} to {_midi_to_name(midi2)}"
+
+
+@register(600, "pitch_tuning")
+def gen_octaver(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 100, 2000)
+    wtype = str(rng.choice(["sine", "sawtooth", "square"]))
+    direction = str(rng.choice(["down", "up"]))
+    t = _t(n)
+    main = _wave(wtype, freq, t)
+    oct_freq = freq / 2 if direction == "down" else freq * 2
+    octave = _wave(wtype, oct_freq, t)
+    mix = rng.uniform(0.3, 0.7)
+    audio = (1 - mix) * main + mix * octave
+    return audio, _pick(rng, ["thick", "wide", "full"]), \
+        f"{_freq_str(freq)} {wtype} with octave-{direction} doubling"
+
+
+@register(600, "pitch_tuning")
+def gen_harmonizer(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 100, 2000)
+    interval_semitones = int(rng.choice([3, 4, 5, 7, 12]))
+    interval_names = {3: "minor third", 4: "major third", 5: "perfect fourth",
+                      7: "perfect fifth", 12: "octave"}
+    interval_name = interval_names.get(interval_semitones, f"{interval_semitones} semitones")
+    t = _t(n)
+    main = np.sin(2 * np.pi * freq * t)
+    harm_freq = freq * 2 ** (interval_semitones / 12)
+    harmony = np.sin(2 * np.pi * harm_freq * t)
+    audio = 0.6 * main + 0.4 * harmony
+    return audio, _pick(rng, CLEAN_DESCS + ["harmonic", "rich"]), \
+        f"{_freq_str(freq)} sine harmonized a {interval_name} above"
+
+
+@register(600, "pitch_tuning")
+def gen_detune(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 100, 2000)
+    detune_hz = rng.uniform(0.5, 5)
+    t = _t(n)
+    audio = 0.5 * (np.sin(2 * np.pi * freq * t) +
+                    np.sin(2 * np.pi * (freq + detune_hz) * t))
+    beat_rate = detune_hz
+    return audio, _pick(rng, ["shimmering", "wavering", "phasing"]), \
+        f"two slightly detuned {_freq_str(freq)} sines creating {beat_rate:.1f} Hz beating"
+
+
+@register(600, "pitch_tuning")
+def gen_formant_shift(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 50, 500)
+    t = _t(n)
+    audio = sig.sawtooth(2 * np.pi * freq * t)
+    # Apply formant-like filter bank at shifted frequencies
+    shift = rng.uniform(0.5, 2.0)
+    formants = [(730 * shift, 80), (1090 * shift, 90), (2440 * shift, 120)]
+    filtered = np.zeros(n)
+    for fc, bw in formants:
+        fc = min(fc, SR / 2 - 200)
+        bw = max(bw, 50)
+        f_lo = max(fc - bw, 20)
+        f_hi = min(fc + bw, SR / 2 - 100)
+        if f_lo >= f_hi:
+            continue
+        sos = _safe_butter(2, [f_lo, f_hi], 'band')
+        if sos is not None:
+            filtered += _apply_sos(audio, sos) * rng.uniform(0.5, 1.0)
+    if np.max(np.abs(filtered)) > 1e-10:
+        audio = filtered
+    depth_desc = "deep" if shift < 0.8 else "high" if shift > 1.3 else "shifted"
+    return audio, _pick(rng, [depth_desc, "vocal", "resonant"]), \
+        f"formant-shifted sawtooth voice-like tone"

generator/generators/special.py

@@ -0,0 +1,133 @@
+"""Category L: Special / Edge Cases — 4,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _freq_str, _pick, _normalize)
+from constants import CLEAN_DESCS, LOW_DESCS, HIGH_DESCS
+
+
+@register(300, "special")
+def gen_silence(rng):
+    dur = _dur(rng)
+    audio = np.zeros(_ns(dur))
+    return audio, [], "complete digital silence"
+
+
+@register(300, "special")
+def gen_near_silence(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio = rng.standard_normal(n) * rng.uniform(0.0001, 0.005)
+    return audio, _pick(rng, ["faint", "barely audible"]), "ambient noise floor"
+
+
+@register(300, "special")
+def gen_dc_offset(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    offset = rng.uniform(0.1, 0.9) * float(rng.choice([-1, 1]))
+    audio = np.full(n, offset)
+    return audio, [], "DC offset signal"
+
+
+@register(300, "special")
+def gen_clipping_max(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Fully saturated signal
+    freq = _log_uniform(rng, 50, 2000)
+    t = _t(n)
+    audio = np.clip(np.sin(2 * np.pi * freq * t) * 10, -1, 1)
+    return audio, _pick(rng, ["saturated", "clipped", "extreme"]), \
+        "fully saturated, clipped audio"
+
+
+@register(300, "special")
+def gen_nyquist(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = rng.uniform(20000, 23000)
+    t = _t(n)
+    audio = np.sin(2 * np.pi * freq * t)
+    return audio, _pick(rng, HIGH_DESCS[:2] + ["ultrasonic"]), \
+        f"near-Nyquist tone at {_freq_str(freq)}"
+
+
+@register(400, "special")
+def gen_sub_bass(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = rng.uniform(20, 60)
+    t = _t(n)
+    audio = np.sin(2 * np.pi * freq * t)
+    # Add slight harmonics for audibility
+    audio += 0.3 * np.sin(2 * np.pi * freq * 2 * t)
+    audio += 0.1 * np.sin(2 * np.pi * freq * 3 * t)
+    return audio, _pick(rng, ["deep", "rumbling", "subby", "seismic"]), \
+        f"sub-bass rumble at {freq:.0f} Hz"
+
+
+@register(300, "special")
+def gen_impulse(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio = np.zeros(n)
+    # Place impulse after fade-in period
+    pos = min(int(0.015 * SR), n - 1)
+    audio[pos] = 1.0
+    return audio, _pick(rng, ["sharp", "transient"]), "single-sample impulse"
+
+
+@register(400, "special")
+def gen_test_tone(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = float(rng.choice([440, 1000, 100, 250, 500, 2000, 4000]))
+    t = _t(n)
+    audio = np.sin(2 * np.pi * freq * t)
+    return audio, _pick(rng, CLEAN_DESCS), f"{_freq_str(freq)} reference test tone"
+
+
+@register(500, "special")
+def gen_sweep(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    f0 = rng.uniform(20, 200)
+    f1 = rng.uniform(5000, 20000)
+    direction = str(rng.choice(["up", "down"]))
+    method = str(rng.choice(["linear", "logarithmic"]))
+    t = _t(n)
+    if direction == "down":
+        f0, f1 = f1, f0
+    audio = sig.chirp(t, f0, t[-1], f1, method=method)
+    return audio, _pick(rng, ["sweeping", "rising" if direction == "up" else "falling"]), \
+        f"{method} frequency sweep from {_freq_str(min(f0, f1))} to {_freq_str(max(f0, f1))}"
+
+
+@register(500, "special")
+def gen_beating(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 200, 2000)
+    beat_rate = rng.uniform(0.5, 10)
+    t = _t(n)
+    audio = 0.5 * (np.sin(2 * np.pi * freq * t) +
+                    np.sin(2 * np.pi * (freq + beat_rate) * t))
+    return audio, _pick(rng, ["pulsing", "wavering", "beating"]), \
+        f"two close tones at {_freq_str(freq)} and {_freq_str(freq + beat_rate)} " \
+        f"creating a {beat_rate:.1f} Hz beat"
+
+
+@register(400, "special")
+def gen_chirp(rng):
+    dur = _dur(rng, 2, 10)
+    n = _ns(dur)
+    f0 = rng.uniform(50, 500)
+    f1 = rng.uniform(1000, 10000)
+    method = str(rng.choice(["linear", "logarithmic"]))
+    t = _t(n)
+    audio = sig.chirp(t, f0, t[-1], f1, method=method)
+    return audio, _pick(rng, ["rising", "sweeping", "accelerating"]), \
+        f"{method} chirp sweeping from {_freq_str(f0)} to {_freq_str(f1)}"

generator/generators/synthesis.py

@@ -0,0 +1,156 @@
+"""Category C: Synthesis Techniques — 12,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _wave, _freq_str,
+                   _midi_to_freq, _midi_to_name, _random_midi, _pick,
+                   _normalize, _pink_noise, _safe_butter, _apply_sos, _adsr)
+from constants import (LOW_DESCS, HIGH_DESCS, CLEAN_DESCS, METAL_DESCS,
+                        BUZZ_DESCS, SOFT_DESCS)
+
+
+@register(2000, "synthesis_techniques")
+def gen_fm(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    carrier = _log_uniform(rng, 50, 2000)
+    ratio = float(rng.choice([0.5, 1, 1.5, 2, 3, 4, 5, 7]))
+    mod_freq = carrier * ratio
+    index = rng.uniform(0.5, 10)
+    t = _t(n)
+    audio = np.sin(2 * np.pi * carrier * t + index * np.sin(2 * np.pi * mod_freq * t))
+    pool = METAL_DESCS if index > 5 else CLEAN_DESCS
+    return audio, _pick(rng, pool), \
+        f"FM synthesis with {_freq_str(carrier)} carrier modulated by {_freq_str(mod_freq)} at index {index:.1f}"
+
+
+@register(1500, "synthesis_techniques")
+def gen_am(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    carrier = _log_uniform(rng, 100, 4000)
+    mod_rate = _log_uniform(rng, 0.5, 50)
+    depth = rng.uniform(0.3, 1.0)
+    t = _t(n)
+    mod = 1.0 - depth + depth * 0.5 * (1 + np.sin(2 * np.pi * mod_rate * t))
+    audio = np.sin(2 * np.pi * carrier * t) * mod
+    return audio, _pick(rng, CLEAN_DESCS + ["trembling", "pulsing"]), \
+        f"amplitude modulation of a {_freq_str(carrier)} sine by a {mod_rate:.1f} Hz modulator"
+
+
+@register(1000, "synthesis_techniques")
+def gen_ring_mod(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq1 = _log_uniform(rng, 100, 2000)
+    freq2 = _log_uniform(rng, 100, 2000)
+    w1 = str(rng.choice(["sine", "square"]))
+    w2 = str(rng.choice(["sine", "square"]))
+    t = _t(n)
+    audio = _wave(w1, freq1, t) * _wave(w2, freq2, t)
+    return audio, _pick(rng, METAL_DESCS + ["dissonant", "inharmonic"]), \
+        f"ring modulation between {_freq_str(freq1)} {w1} and {_freq_str(freq2)} {w2}"
+
+
+@register(1500, "synthesis_techniques")
+def gen_additive(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    fundamental = _log_uniform(rng, 50, 1000)
+    n_partials = int(rng.integers(4, 20))
+    t = _t(n)
+    audio = np.zeros(n)
+    for h in range(1, n_partials + 1):
+        f = fundamental * h
+        if f > SR / 2:
+            break
+        amp = rng.uniform(0.1, 1.0) / h ** rng.uniform(0.3, 1.5)
+        audio += amp * np.sin(2 * np.pi * f * t + rng.uniform(0, 2 * np.pi))
+    return audio, _pick(rng, CLEAN_DESCS + ["rich", "complex"]), \
+        f"additive synthesis with {n_partials} harmonic partials on {_freq_str(fundamental)}"
+
+
+@register(1500, "synthesis_techniques")
+def gen_subtractive(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 50, 2000)
+    wtype = str(rng.choice(["sawtooth", "square"]))
+    t = _t(n)
+    audio = _wave(wtype, freq, t)
+    cutoff = _log_uniform(rng, 200, 8000)
+    resonance = rng.uniform(0.5, 5)
+    sos = _safe_butter(4, cutoff, 'low')
+    if sos is not None:
+        audio = _apply_sos(audio, sos)
+    pool = LOW_DESCS if cutoff < 1000 else CLEAN_DESCS
+    return audio, _pick(rng, pool), \
+        f"subtractive synthesis: {wtype} through low-pass filter at {_freq_str(cutoff)}"
+
+
+@register(1500, "synthesis_techniques")
+def gen_granular(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Source sound
+    src_type = str(rng.choice(["sine", "noise"]))
+    if src_type == "sine":
+        freq = _log_uniform(rng, 100, 2000)
+        src = np.sin(2 * np.pi * freq * _t(n))
+        src_desc = "sine"
+    else:
+        src = rng.standard_normal(n)
+        src_desc = "noise"
+    grain_ms = rng.uniform(5, 50)
+    grain_size = max(int(grain_ms * SR / 1000), 64)
+    density = rng.uniform(10, 100)
+    n_grains = int(density * dur)
+    audio = np.zeros(n)
+    window = np.hanning(grain_size)
+    for _ in range(n_grains):
+        src_pos = int(rng.integers(0, max(n - grain_size, 1)))
+        out_pos = int(rng.integers(0, max(n - grain_size, 1)))
+        end = min(out_pos + grain_size, n)
+        gl = end - out_pos
+        audio[out_pos:end] += src[src_pos:src_pos + gl] * window[:gl]
+    return audio, _pick(rng, ["shimmering", "textural", "scattered", "ethereal"]), \
+        f"granular texture of tiny {src_desc} grains"
+
+
+@register(1500, "synthesis_techniques")
+def gen_karplus_strong(rng):
+    dur = _dur(rng, 2, 10)
+    n = _ns(dur)
+    midi = _random_midi(rng, 36, 84)
+    freq = _midi_to_freq(midi)
+    brightness = rng.uniform(0.3, 0.7)
+    D = max(int(SR / freq), 2)
+    out = np.zeros(n)
+    out[:D] = rng.uniform(-1, 1, D)
+    for i in range(D, n):
+        out[i] = brightness * out[i - D] + (1 - brightness) * out[i - D + 1]
+    pool = METAL_DESCS if brightness > 0.5 else SOFT_DESCS
+    return out, _pick(rng, pool), \
+        f"Karplus-Strong plucked string at {_midi_to_name(midi)}"
+
+
+@register(1000, "synthesis_techniques")
+def gen_physical_model(rng):
+    dur = _dur(rng, 2, 10)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 200, 2000)
+    t = _t(n)
+    # Bar mode ratios (inharmonic)
+    ratios = [1, 2.756, 5.404, 8.933, 13.344]
+    audio = np.zeros(n)
+    for i, r in enumerate(ratios):
+        f = freq * r
+        if f > SR / 2:
+            break
+        decay = rng.uniform(0.5, 3.0) / (i + 1)
+        amp = 1.0 / (i + 1) ** 0.5
+        audio += amp * np.sin(2 * np.pi * f * t) * np.exp(-t / decay)
+    return audio, _pick(rng, METAL_DESCS), \
+        f"physical model of a struck metallic bar at {_freq_str(freq)}"

generator/generators/time_effects.py

@@ -0,0 +1,222 @@
+"""Category I: Time-Based Effects — 6,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _freq_str,
+                   _random_base, _random_source, _pick, _apply_delay,
+                   _reverb_ir, _apply_reverb, _safe_butter, _apply_sos,
+                   _make_kick, _make_snare, _make_hihat, _normalize)
+from constants import REVERB_DESCS, CLEAN_DESCS, METAL_DESCS, SOFT_DESCS
+
+
+@register(600, "time_effects")
+def gen_delay(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    delay_time = rng.uniform(0.1, 0.5)
+    feedback = rng.uniform(0.3, 0.7)
+    audio = _apply_delay(audio, delay_time, feedback, wet=rng.uniform(0.2, 0.5))
+    return audio, _pick(rng, CLEAN_DESCS + ["echoing"]), \
+        f"{desc} with clean delay echoes"
+
+
+@register(500, "time_effects")
+def gen_slapback(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Short percussive source
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    delay_time = rng.uniform(0.03, 0.12)
+    audio = _apply_delay(audio, delay_time, feedback=0.1, wet=rng.uniform(0.3, 0.6), n_echoes=2)
+    return audio, _pick(rng, ["snappy", "doubled"]), \
+        f"{desc} with short slapback delay"
+
+
+@register(500, "time_effects")
+def gen_pingpong(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    delay_time = rng.uniform(0.15, 0.5)
+    feedback = rng.uniform(0.3, 0.6)
+    # Simulate ping-pong: alternating amplitude between echoes
+    d = max(int(delay_time * SR), 1)
+    out = audio.copy()
+    for i in range(1, 10):
+        pos = i * d
+        if pos >= n:
+            break
+        gain = feedback ** i
+        pan = 0.5 + 0.3 * ((-1) ** i)  # alternating levels
+        end = min(n, pos + n - pos)
+        out[pos:end] += gain * pan * audio[:end - pos]
+    out = _normalize(out)
+    return out, _pick(rng, ["bouncing", "stereo-like", "rhythmic"]), \
+        f"{desc} bouncing in ping-pong delay"
+
+
+@register(500, "time_effects")
+def gen_multitap(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    n_taps = int(rng.integers(3, 7))
+    out = audio.copy()
+    for tap in range(n_taps):
+        delay = rng.uniform(0.05, 0.6)
+        gain = rng.uniform(0.2, 0.6)
+        d = int(delay * SR)
+        if d < n:
+            out[d:] += gain * audio[:n - d]
+    out = _normalize(out)
+    return out, _pick(rng, ["rhythmic", "echoing", "complex"]), \
+        f"multi-tap delay creating rhythmic echoes from {desc}"
+
+
+@register(500, "time_effects")
+def gen_tape_delay(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_base(rng, n, allow_noise=False)
+    delay_time = rng.uniform(0.2, 0.5)
+    feedback = rng.uniform(0.4, 0.7)
+    d = max(int(delay_time * SR), 1)
+    out = audio.copy()
+    echo = audio.copy()
+    for i in range(1, 8):
+        pos = i * d
+        if pos >= n:
+            break
+        # Degrade each echo (low-pass + slight noise)
+        sos = _safe_butter(2, max(8000 - i * 1000, 1000), 'low')
+        if sos is not None:
+            echo = _apply_sos(echo, sos)
+        gain = feedback ** i
+        end = min(n, pos + len(echo))
+        out[pos:end] += gain * echo[:end - pos]
+    out = _normalize(out)
+    return out, _pick(rng, ["warm", "degrading", "analog", "tape-like"]), \
+        f"warm, degrading tape delay on {desc}"
+
+
+@register(500, "time_effects")
+def gen_reverb_room(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    rt60 = rng.uniform(0.3, 1.0)
+    ir = _reverb_ir(rng, rt60, "room")
+    wet = rng.uniform(0.2, 0.5)
+    audio = _apply_reverb(audio, ir, wet)
+    return audio, _pick(rng, ["roomy", "natural"] + REVERB_DESCS[:2]), \
+        f"{desc} in a small room reverb"
+
+
+@register(500, "time_effects")
+def gen_reverb_hall(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    rt60 = rng.uniform(2, 6)
+    ir = _reverb_ir(rng, rt60, "hall")
+    wet = rng.uniform(0.3, 0.6)
+    audio = _apply_reverb(audio, ir, wet)
+    return audio, _pick(rng, REVERB_DESCS), \
+        f"{desc} in a spacious hall reverb"
+
+
+@register(500, "time_effects")
+def gen_reverb_plate(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    rt60 = rng.uniform(1, 3)
+    ir = _reverb_ir(rng, rt60, "plate")
+    wet = rng.uniform(0.2, 0.5)
+    audio = _apply_reverb(audio, ir, wet)
+    return audio, _pick(rng, ["bright", "dense", "shimmery"]), \
+        f"plate reverb on {desc}"
+
+
+@register(400, "time_effects")
+def gen_reverb_spring(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    rt60 = rng.uniform(0.5, 2)
+    ir = _reverb_ir(rng, rt60, "spring")
+    wet = rng.uniform(0.2, 0.5)
+    audio = _apply_reverb(audio, ir, wet)
+    return audio, _pick(rng, METAL_DESCS[:2] + ["springy", "boingy"]), \
+        f"metallic spring reverb on {desc}"
+
+
+@register(500, "time_effects")
+def gen_gated_reverb(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    # Percussive source
+    hit_n = min(int(0.3 * SR), n)
+    hit = _make_snare(rng, hit_n)
+    audio = np.zeros(n)
+    # Place hits
+    period = int(rng.uniform(0.5, 1.5) * SR)
+    for pos in range(0, n, period):
+        end = min(pos + hit_n, n)
+        audio[pos:end] += hit[:end - pos]
+    # Apply reverb
+    rt60 = rng.uniform(1, 3)
+    ir = _reverb_ir(rng, rt60, "room")
+    reverbed = _apply_reverb(audio, ir, wet=0.6)
+    # Gate: cut reverb tail sharply
+    gate_time = rng.uniform(0.1, 0.3)
+    gate_n = int(gate_time * SR)
+    gate_env = np.ones(n)
+    for pos in range(0, n, period):
+        cut = min(pos + gate_n, n)
+        if cut < n:
+            gate_env[cut:min(cut + int(0.01 * SR), n)] *= np.linspace(1, 0,
+                min(int(0.01 * SR), n - cut))
+            gate_env[min(cut + int(0.01 * SR), n):min(pos + period, n)] = 0
+    audio = reverbed * gate_env
+    return audio, _pick(rng, ["punchy", "80s", "powerful", "explosive"]), \
+        "snare with gated reverb"
+
+
+@register(500, "time_effects")
+def gen_shimmer_reverb(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    rt60 = rng.uniform(2, 5)
+    ir = _reverb_ir(rng, rt60, "hall")
+    reverbed = sig.fftconvolve(audio, ir, mode='full')[:n]
+    # Pitch-shift reverb tail up an octave (simple: resample)
+    half = sig.resample(reverbed, n // 2)
+    shifted = np.zeros(n)
+    shifted[:len(half)] = half
+    wet = rng.uniform(0.2, 0.4)
+    audio = (1 - wet) * audio + wet * 0.5 * (reverbed[:n] + shifted[:n])
+    audio = _normalize(audio)
+    return audio, _pick(rng, ["shimmering", "ethereal", "celestial", "sparkling"]), \
+        f"shimmering, pitch-shifted reverb on {desc}"
+
+
+@register(500, "time_effects")
+def gen_reverse_reverb(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    audio, desc, _ = _random_source(rng, n)
+    rt60 = rng.uniform(1, 3)
+    ir = _reverb_ir(rng, rt60, "hall")
+    # Reverse audio, apply reverb, reverse back
+    reversed_audio = audio[::-1]
+    reverbed = sig.fftconvolve(reversed_audio, ir, mode='full')[:n]
+    reverse_reverbed = reverbed[::-1]
+    wet = rng.uniform(0.3, 0.6)
+    audio = (1 - wet) * audio + wet * _normalize(reverse_reverbed)
+    return audio, _pick(rng, ["swelling", "ghostly", "reversed"]), \
+        f"reversed reverb swell into {desc}"

generator/generators/waveforms.py

@@ -0,0 +1,162 @@
+"""Category A: Waveforms & Basic Synth Sources — 14,000 samples."""
+
+import numpy as np
+from scipy import signal as sig
+
+from generators import register
+from utils import (SR, _dur, _ns, _t, _log_uniform, _wave, _freq_str,
+                   _midi_to_freq, _midi_to_name, _random_midi, _pick, _normalize,
+                   _pink_noise, _brown_noise, _adsr)
+from constants import LOW_DESCS, HIGH_DESCS, CLEAN_DESCS, BUZZ_DESCS, SOFT_DESCS
+
+
+@register(1500, "basic_waveforms")
+def gen_sine(rng):
+    dur = _dur(rng)
+    freq = _log_uniform(rng, 20, 20000)
+    t = _t(_ns(dur))
+    audio = np.sin(2 * np.pi * freq * t)
+    pool = CLEAN_DESCS if freq < 5000 else HIGH_DESCS
+    return audio, _pick(rng, pool), f"{_freq_str(freq)} sine wave"
+
+
+@register(1500, "basic_waveforms")
+def gen_square(rng):
+    dur = _dur(rng)
+    freq = _log_uniform(rng, 20, 10000)
+    duty = rng.uniform(0.1, 0.9)
+    t = _t(_ns(dur))
+    audio = sig.square(2 * np.pi * freq * t, duty=duty)
+    duty_s = f" with {duty * 100:.0f}% duty cycle" if abs(duty - 0.5) > 0.1 else ""
+    return audio, _pick(rng, HIGH_DESCS + BUZZ_DESCS), f"{_freq_str(freq)} square wave{duty_s}"
+
+
+@register(1500, "basic_waveforms")
+def gen_sawtooth(rng):
+    dur = _dur(rng)
+    freq = _log_uniform(rng, 20, 10000)
+    t = _t(_ns(dur))
+    audio = sig.sawtooth(2 * np.pi * freq * t)
+    return audio, _pick(rng, HIGH_DESCS + BUZZ_DESCS), f"{_freq_str(freq)} sawtooth wave"
+
+
+@register(1500, "basic_waveforms")
+def gen_triangle(rng):
+    dur = _dur(rng)
+    freq = _log_uniform(rng, 20, 10000)
+    t = _t(_ns(dur))
+    audio = sig.sawtooth(2 * np.pi * freq * t, width=0.5)
+    return audio, _pick(rng, SOFT_DESCS + CLEAN_DESCS), f"{_freq_str(freq)} triangle wave"
+
+
+@register(1000, "basic_waveforms")
+def gen_pulse_pwm(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 50, 5000)
+    t = _t(n)
+    duty_start = rng.uniform(0.1, 0.9)
+    duty_end = rng.uniform(0.1, 0.9)
+    duty_sweep = np.linspace(duty_start, duty_end, n)
+    phase = 2 * np.pi * freq * t
+    audio = np.where(np.mod(phase, 2 * np.pi) / (2 * np.pi) < duty_sweep, 1.0, -1.0)
+    return audio, _pick(rng, BUZZ_DESCS), f"{_freq_str(freq)} pulse wave with sweeping duty cycle"
+
+
+@register(1500, "basic_waveforms")
+def gen_supersaw(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    midi = _random_midi(rng, 36, 72)
+    freq = _midi_to_freq(midi)
+    n_voices = int(rng.integers(3, 9))
+    detune_cents = rng.uniform(0.1, 30)
+    t = _t(n)
+    audio = np.zeros(n)
+    for v in range(n_voices):
+        cents = rng.uniform(-detune_cents, detune_cents)
+        f = freq * 2 ** (cents / 1200)
+        audio += sig.sawtooth(2 * np.pi * f * t + rng.uniform(0, 2 * np.pi))
+    audio /= n_voices
+    note = _midi_to_name(midi)
+    return audio, _pick(rng, ["thick", "wide", "lush", "massive"]), \
+        f"supersaw with {n_voices} detuned voices at {note}"
+
+
+@register(1000, "basic_waveforms")
+def gen_wavetable(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 80, 2000)
+    t = _t(n)
+    shapes = ["sine", "square", "sawtooth", "triangle"]
+    s1, s2 = rng.choice(shapes, size=2, replace=False)
+    morph = np.linspace(0, 1, n)
+    w1 = _wave(s1, freq, t)
+    w2 = _wave(s2, freq, t)
+    audio = (1 - morph) * w1 + morph * w2
+    return audio, _pick(rng, ["evolving", "morphing", "shifting"]), \
+        f"wavetable oscillator morphing from {s1} to {s2} at {_freq_str(freq)}"
+
+
+@register(500, "basic_waveforms")
+def gen_sample_hold(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    hold_samples = int(rng.uniform(10, 500))
+    n_steps = n // hold_samples + 1
+    levels = rng.uniform(-1, 1, n_steps)
+    audio = np.repeat(levels, hold_samples)[:n]
+    rate_hz = SR / hold_samples
+    return audio, _pick(rng, BUZZ_DESCS + ["stepped", "random"]), \
+        f"sample-and-hold noise oscillator at {rate_hz:.0f} Hz rate"
+
+
+@register(500, "basic_waveforms")
+def gen_bit_noise(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    bit_rate = int(_log_uniform(rng, 100, 20000))
+    hold = max(SR // bit_rate, 1)
+    n_steps = n // hold + 1
+    bits = rng.choice([-1.0, 1.0], size=n_steps)
+    audio = np.repeat(bits, hold)[:n]
+    return audio, _pick(rng, ["harsh", "metallic", "digital", "noisy"]), \
+        f"bit noise generator at {bit_rate} Hz"
+
+
+@register(1000, "basic_waveforms")
+def gen_unison_detune(rng):
+    dur = _dur(rng)
+    n = _ns(dur)
+    midi = _random_midi(rng, 36, 84)
+    freq = _midi_to_freq(midi)
+    wtype = str(rng.choice(["sine", "sawtooth", "square", "triangle"]))
+    n_voices = int(rng.integers(2, 9))
+    detune = rng.uniform(0.5, 15)
+    t = _t(n)
+    audio = np.zeros(n)
+    for v in range(n_voices):
+        cents = rng.uniform(-detune, detune)
+        f = freq * 2 ** (cents / 1200)
+        audio += _wave(wtype, f, t + rng.uniform(0, 1.0 / f))
+    audio /= n_voices
+    return audio, _pick(rng, ["wide", "thick", "lush", "detuned"]), \
+        f"detuned unison {wtype} at {_midi_to_name(midi)}"
+
+
+@register(1500, "basic_waveforms")
+def gen_drone(rng):
+    dur = _dur(rng, 5, 20)
+    n = _ns(dur)
+    freq = _log_uniform(rng, 30, 200)
+    t = _t(n)
+    # Base tone + harmonics with slow movement
+    audio = np.sin(2 * np.pi * freq * t)
+    for h in range(2, int(rng.integers(4, 10))):
+        lfo_rate = rng.uniform(0.01, 0.2)
+        lfo = 0.5 + 0.5 * np.sin(2 * np.pi * lfo_rate * t + rng.uniform(0, 2 * np.pi))
+        amp = rng.uniform(0.1, 0.5) / h
+        audio += amp * lfo * np.sin(2 * np.pi * freq * h * t)
+    return audio, _pick(rng, LOW_DESCS + ["droning", "sustained"]), \
+        f"drone at {_freq_str(freq)} with slow harmonic movement"

generator/slurm_generate.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+#SBATCH --job-name=gen-prog-audio
+#SBATCH --account=laionize
+#SBATCH --partition=batch
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=48
+#SBATCH --threads-per-core=2
+#SBATCH --time=06:00:00
+#SBATCH --output=programmatic_audio/logs/generate_%j.out
+#SBATCH --error=programmatic_audio/logs/generate_%j.err
+
+source /p/project1/ccstdl/wijngaard1/miniforge3/etc/profile.d/conda.sh
+conda activate clapv2
+cd /p/project1/ccstdl/wijngaard1/clapv2
+
+python -u programmatic_audio/generate.py --workers 92 --seed 42

generator/utils.py

@@ -0,0 +1,408 @@
+"""Audio utility functions for programmatic audio generation."""
+
+import numpy as np
+from scipy import signal
+
+SR = 48000
+SAMPLES_PER_TAR = 4096
+
+
+# ── Duration / sample helpers ─────────────────────────────────────────────────
+
+def _dur(rng, lo=2.0, hi=20.0):
+    return rng.uniform(lo, hi)
+
+
+def _ns(dur):
+    return int(dur * SR)
+
+
+def _t(n):
+    return np.arange(n) / SR
+
+
+def _log_uniform(rng, lo, hi):
+    return np.exp(rng.uniform(np.log(lo), np.log(hi)))
+
+
+# ── MIDI / note helpers ───────────────────────────────────────────────────────
+
+def _midi_to_freq(midi):
+    return 440.0 * 2.0 ** ((midi - 69) / 12.0)
+
+
+def _midi_to_name(midi):
+    from constants import NOTE_NAMES
+    return f"{NOTE_NAMES[int(midi) % 12]}{int(midi) // 12 - 1}"
+
+
+def _random_midi(rng, lo=36, hi=84):
+    return int(rng.integers(lo, hi + 1))
+
+
+def _freq_str(freq):
+    if freq >= 1000:
+        return f"{freq / 1000:.1f} kHz"
+    elif freq >= 100:
+        return f"{freq:.0f} Hz"
+    return f"{freq:.1f} Hz"
+
+
+# ── Waveform generation ──────────────────────────────────────────────────────
+
+def _wave(wtype, freq, t):
+    phase = 2 * np.pi * freq * t
+    if wtype == "sine":
+        return np.sin(phase)
+    elif wtype == "square":
+        return signal.square(phase)
+    elif wtype == "sawtooth":
+        return signal.sawtooth(phase)
+    elif wtype == "triangle":
+        return signal.sawtooth(phase, width=0.5)
+    raise ValueError(f"Unknown wave type: {wtype}")
+
+
+# ── Descriptor / caption helpers ──────────────────────────────────────────────
+
+def _pick(rng, pool, max_n=2):
+    """Pick 0-2 descriptors from pool."""
+    if not pool:
+        return []
+    n = int(rng.choice([0, 0, 1, 1, 1, 2]))
+    n = min(n, max_n, len(pool))
+    if n == 0:
+        return []
+    return list(rng.choice(pool, size=n, replace=False))
+
+
+def _vol_word(rng, amp):
+    if amp < 0.15:
+        return "very quiet"
+    elif amp < 0.35:
+        return str(rng.choice(["quiet", "soft"]))
+    elif amp < 0.65:
+        return ""
+    elif amp < 0.85:
+        return "loud"
+    return "very loud"
+
+
+def _build_caption(vol, descs, core):
+    parts = []
+    if vol:
+        parts.append(vol)
+    parts.extend(descs)
+    if parts:
+        return f"A {', '.join(parts)} {core}"
+    return f"A {core}"
+
+
+# ── Noise generators ─────────────────────────────────────────────────────────
+
+def _normalize(audio):
+    peak = np.max(np.abs(audio))
+    return audio / peak if peak > 1e-10 else audio
+
+
+def _pink_noise(rng, n):
+    white = rng.standard_normal(n)
+    fft = np.fft.rfft(white)
+    freqs = np.fft.rfftfreq(n, 1.0 / SR)
+    freqs[0] = 1
+    fft /= np.sqrt(freqs)
+    return _normalize(np.fft.irfft(fft, n))
+
+
+def _brown_noise(rng, n):
+    out = np.cumsum(rng.standard_normal(n))
+    out -= np.mean(out)
+    return _normalize(out)
+
+
+def _blue_noise(rng, n):
+    return _normalize(np.diff(rng.standard_normal(n + 1)))
+
+
+def _violet_noise(rng, n):
+    w = rng.standard_normal(n + 2)
+    return _normalize(np.diff(np.diff(w)))
+
+
+def _grey_noise(rng, n):
+    white = rng.standard_normal(n)
+    fft = np.fft.rfft(white)
+    freqs = np.fft.rfftfreq(n, 1.0 / SR)
+    f = np.maximum(freqs, 1.0)
+    a = (12194**2 * f**4) / (
+        (f**2 + 20.6**2)
+        * np.sqrt((f**2 + 107.7**2) * (f**2 + 737.9**2))
+        * (f**2 + 12194**2)
+    )
+    a /= np.max(a)
+    fft /= (a + 1e-10)
+    return _normalize(np.fft.irfft(fft, n))
+
+
+# ── Envelope ──────────────────────────────────────────────────────────────────
+
+def _adsr(dur, attack=0.01, decay=0.05, sustain=0.7, release=0.1):
+    n = _ns(dur)
+    a_n = min(int(attack * SR), n)
+    d_n = min(int(decay * SR), max(n - a_n, 0))
+    r_n = min(int(release * SR), max(n - a_n - d_n, 0))
+    s_n = max(n - a_n - d_n - r_n, 0)
+    env = np.concatenate([
+        np.linspace(0, 1, max(a_n, 1)),
+        np.linspace(1, sustain, max(d_n, 1)),
+        np.full(s_n, sustain),
+        np.linspace(sustain, 0, max(r_n, 1)),
+    ])[:n]
+    if len(env) < n:
+        env = np.pad(env, (0, n - len(env)))
+    return env
+
+
+# ── Filter helpers ────────────────────────────────────────────────────────────
+
+def _safe_butter(order, freq, btype, fs=SR):
+    nyq = fs / 2
+    if isinstance(freq, (list, tuple, np.ndarray)):
+        freq = [max(20, min(f, nyq - 100)) for f in freq]
+        if freq[0] >= freq[1]:
+            return None
+    else:
+        freq = max(20, min(freq, nyq - 100))
+    try:
+        return signal.butter(order, freq, btype=btype, fs=fs, output='sos')
+    except Exception:
+        return None
+
+
+def _apply_sos(audio, sos):
+    if sos is None:
+        return audio
+    try:
+        return signal.sosfilt(sos, audio)
+    except Exception:
+        return audio
+
+
+def _peaking_eq(freq, gain_db, Q):
+    """Design a peaking EQ biquad. Returns (b, a)."""
+    A = 10 ** (gain_db / 40)
+    w0 = 2 * np.pi * freq / SR
+    alpha = np.sin(w0) / (2 * Q)
+    b0 = 1 + alpha * A
+    b1 = -2 * np.cos(w0)
+    b2 = 1 - alpha * A
+    a0 = 1 + alpha / A
+    a1 = -2 * np.cos(w0)
+    a2 = 1 - alpha / A
+    return np.array([b0, b1, b2]) / a0, np.array([1, a1, a2]) / a0
+
+
+def _shelf_eq(freq, gain_db, shelf_type='high'):
+    """Design a shelving EQ. Returns (b, a)."""
+    A = 10 ** (gain_db / 40)
+    w0 = 2 * np.pi * freq / SR
+    alpha = np.sin(w0) / 2 * np.sqrt((A + 1 / A) * (1 / 0.707 - 1) + 2)
+    cos_w0 = np.cos(w0)
+    sqA = np.sqrt(A)
+    if shelf_type == 'low':
+        b0 = A * ((A + 1) - (A - 1) * cos_w0 + 2 * sqA * alpha)
+        b1 = 2 * A * ((A - 1) - (A + 1) * cos_w0)
+        b2 = A * ((A + 1) - (A - 1) * cos_w0 - 2 * sqA * alpha)
+        a0 = (A + 1) + (A - 1) * cos_w0 + 2 * sqA * alpha
+        a1 = -2 * ((A - 1) + (A + 1) * cos_w0)
+        a2 = (A + 1) + (A - 1) * cos_w0 - 2 * sqA * alpha
+    else:
+        b0 = A * ((A + 1) + (A - 1) * cos_w0 + 2 * sqA * alpha)
+        b1 = -2 * A * ((A - 1) + (A + 1) * cos_w0)
+        b2 = A * ((A + 1) + (A - 1) * cos_w0 - 2 * sqA * alpha)
+        a0 = (A + 1) - (A - 1) * cos_w0 + 2 * sqA * alpha
+        a1 = 2 * ((A - 1) - (A + 1) * cos_w0)
+        a2 = (A + 1) - (A - 1) * cos_w0 - 2 * sqA * alpha
+    return np.array([b0, b1, b2]) / a0, np.array([1, a1, a2]) / a0
+
+
+# ── Random base sound helpers ─────────────────────────────────────────────────
+
+def _random_base(rng, n, allow_noise=True):
+    """Simple random base waveform. Returns (audio, description, params)."""
+    choices = ["sine", "square", "sawtooth", "triangle"]
+    if allow_noise:
+        choices += ["white_noise", "pink_noise"]
+    choice = str(rng.choice(choices))
+    if choice == "white_noise":
+        return rng.standard_normal(n), "white noise", {"is_noise": True}
+    elif choice == "pink_noise":
+        return _pink_noise(rng, n), "pink noise", {"is_noise": True}
+    freq = _log_uniform(rng, 80, 4000)
+    t = _t(n)
+    audio = _wave(choice, freq, t)
+    return audio, f"{_freq_str(freq)} {choice} wave", {"freq": freq, "wave_type": choice}
+
+
+def _random_source(rng, n):
+    """Richer random sound source (includes chords, FM, pads)."""
+    choice = int(rng.integers(0, 8))
+    if choice <= 3:
+        return _random_base(rng, n)
+    elif choice == 4:
+        root = _random_midi(rng, 48, 72)
+        intervals = [[0, 4, 7], [0, 3, 7], [0, 4, 7, 11]][int(rng.integers(0, 3))]
+        t = _t(n)
+        audio = sum(_wave("sine", _midi_to_freq(root + iv), t) for iv in intervals)
+        audio /= len(intervals)
+        return audio, f"{_midi_to_name(root)} chord", {"freq": _midi_to_freq(root)}
+    elif choice == 5:
+        carrier = _log_uniform(rng, 100, 1000)
+        ratio = float(rng.choice([1, 2, 3, 4]))
+        index = rng.uniform(1, 5)
+        t = _t(n)
+        audio = np.sin(2 * np.pi * carrier * t + index * np.sin(2 * np.pi * carrier * ratio * t))
+        return audio, f"FM tone at {_freq_str(carrier)}", {"freq": carrier}
+    elif choice == 6:
+        freq = _log_uniform(rng, 30, 200)
+        t = _t(n)
+        audio = np.sin(2 * np.pi * freq * t) + 0.5 * np.sin(4 * np.pi * freq * t)
+        audio += 0.3 * np.sin(6 * np.pi * freq * t)
+        return audio, f"drone at {_freq_str(freq)}", {"freq": freq}
+    else:
+        freq = _midi_to_freq(_random_midi(rng, 48, 72))
+        t = _t(n)
+        n_v = int(rng.integers(3, 7))
+        audio = np.zeros(n)
+        for _ in range(n_v):
+            audio += signal.sawtooth(2 * np.pi * freq * (1 + rng.uniform(-0.02, 0.02)) * t)
+        audio /= n_v
+        return audio, f"pad at {_freq_str(freq)}", {"freq": freq}
+
+
+# ── Effect helpers ────────────────────────────────────────────────────────────
+
+def _reverb_ir(rng, rt60, ir_type="room"):
+    n = max(int(rt60 * SR), SR // 10)
+    ir = rng.standard_normal(n)
+    decay = np.exp(-6.908 * np.arange(n) / n)
+    ir *= decay
+    if ir_type == "room":
+        for _ in range(int(rng.integers(3, 8))):
+            pos = int(rng.uniform(0.005, 0.05) * SR)
+            if pos < n:
+                ir[pos] += rng.uniform(0.3, 0.7) * float(rng.choice([-1, 1]))
+    elif ir_type == "plate":
+        sos = _safe_butter(2, 500, 'high')
+        if sos is not None:
+            ir = signal.sosfilt(sos, ir)
+    elif ir_type == "spring":
+        chirp_f = rng.uniform(50, 200)
+        t_ir = np.arange(n) / SR
+        ir *= np.sin(2 * np.pi * chirp_f * t_ir * (1 + 0.5 * t_ir))
+    elif ir_type == "hall":
+        ir += 0.3 * rng.standard_normal(n) * decay ** 0.8
+    return _normalize(ir)
+
+
+def _apply_reverb(audio, ir, wet=0.3):
+    reverbed = signal.fftconvolve(audio, ir, mode='full')[:len(audio)]
+    peak = np.max(np.abs(reverbed))
+    if peak > 1e-10:
+        reverbed = reverbed / peak * np.max(np.abs(audio))
+    return (1 - wet) * audio + wet * reverbed
+
+
+def _apply_delay(audio, delay_time, feedback=0.5, wet=0.3, n_echoes=8):
+    d = max(int(delay_time * SR), 1)
+    out = audio.copy()
+    for i in range(1, n_echoes + 1):
+        pos = i * d
+        if pos >= len(audio):
+            break
+        gain = feedback ** i
+        end = len(audio)
+        out[pos:end] += gain * audio[:end - pos]
+    peak = np.max(np.abs(out))
+    if peak > 1e-10:
+        out = out / peak * np.max(np.abs(audio))
+    return (1 - wet) * audio + wet * out
+
+
+def _compress(audio, threshold_db=-10, ratio=4):
+    threshold = 10 ** (threshold_db / 20)
+    env = np.abs(audio)
+    sos = _safe_butter(1, 100, 'low')
+    if sos is not None:
+        env = np.maximum(signal.sosfilt(sos, env), 1e-10)
+    else:
+        env = np.maximum(env, 1e-10)
+    gain = np.ones_like(env)
+    above = env > threshold
+    gain[above] = (threshold / env[above]) ** (1 - 1 / ratio)
+    return audio * gain
+
+
+def _chorus(audio, rng):
+    n = len(audio)
+    rate = rng.uniform(0.5, 3)
+    depth = int(rng.uniform(0.002, 0.01) * SR)
+    base_delay = int(0.02 * SR)
+    t = np.arange(n) / SR
+    delay = base_delay + (depth * np.sin(2 * np.pi * rate * t)).astype(int)
+    indices = np.clip(np.arange(n) - delay, 0, n - 1)
+    return 0.7 * audio + 0.3 * audio[indices]
+
+
+def _flanger(audio, rng):
+    n = len(audio)
+    rate = rng.uniform(0.1, 1)
+    depth = max(int(rng.uniform(0.001, 0.005) * SR), 1)
+    t = np.arange(n) / SR
+    delay = (depth * (1 + np.sin(2 * np.pi * rate * t)) / 2).astype(int) + 1
+    indices = np.clip(np.arange(n) - delay, 0, n - 1)
+    fb = rng.uniform(0.3, 0.7)
+    return audio + fb * audio[indices]
+
+
+def _sidechain_pump(audio, bpm, depth=0.8, curve=3.0):
+    beat_samples = max(int(SR * 60 / bpm), 1)
+    env = np.power(np.linspace(0, 1, beat_samples), curve)
+    env = 1.0 - depth * (1.0 - env)
+    full_env = np.tile(env, len(audio) // beat_samples + 1)[:len(audio)]
+    return audio * full_env
+
+
+# ── Drum synthesis helpers ────────────────────────────────────────────────────
+
+def _make_kick(rng, n):
+    t = _t(n)
+    f_start = rng.uniform(150, 300)
+    f_end = rng.uniform(30, 60)
+    freq_env = f_end + (f_start - f_end) * np.exp(-t * rng.uniform(20, 60))
+    phase = np.cumsum(2 * np.pi * freq_env / SR)
+    body = np.sin(phase)
+    amp_env = np.exp(-t * rng.uniform(3, 10))
+    click = np.zeros(n)
+    cl = min(int(0.005 * SR), n)
+    click[:cl] = rng.uniform(0.3, 0.8) * np.exp(-np.arange(cl) / (0.001 * SR))
+    return (body * amp_env + click) * 0.8
+
+
+def _make_snare(rng, n):
+    t = _t(n)
+    body = np.sin(2 * np.pi * rng.uniform(150, 250) * t) * np.exp(-t * rng.uniform(15, 30))
+    noise = rng.standard_normal(n) * np.exp(-t * rng.uniform(8, 20))
+    sos = _safe_butter(4, rng.uniform(2000, 8000), 'high')
+    if sos is not None:
+        noise = signal.sosfilt(sos, noise)
+    return 0.5 * body + 0.5 * noise
+
+
+def _make_hihat(rng, n):
+    t = _t(n)
+    noise = rng.standard_normal(n)
+    sos = _safe_butter(4, rng.uniform(5000, 12000), 'high')
+    if sos is not None:
+        noise = signal.sosfilt(sos, noise)
+    return noise * np.exp(-t * rng.uniform(20, 80))

train/0001.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08443b394750312fb9aec72903dd8ad03c7a5a846364d92f0859f26ebd9fe039
+size 2031523840

train/0002.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:367d4e6d6d317974ee90edd00c059f37f14251e201f61f374e0a0bd5f7c48fb9
+size 2406379520

train/0003.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e492f6cdf749939eb7413d44fe8ee9671338207fd0affe6ea86c9d496364000d
+size 1978798080

train/0004.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0ca1bcf153a98dd8379e90962311789ce78ff6905d662e0000028b108a86eba
+size 2699714560

train/0005.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d11d42a1c09c08856a80a46686b0be6cf78730f42eef8ec7325896cfca82728
+size 2115788800

train/0006.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d876c2bd66ea1cc2010abdcbcbc03658960b9df4a1b1416b1d0a499917851651
+size 1612390400

train/0007.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb7863afc9a062afead73b25b30757fb95182f9226c8dcff40a1418f58d79bac
+size 1182382080

train/0008.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb68c100a6370ca3dcbe454644af1db66503cb80ba32cf4dae7def53a7ba0792
+size 1241937920

train/0009.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a33e184a9aa2ca8a69e46a4b84584eb7453aba0b57cb4f1aee07b9c5d52080f0
+size 1681203200

train/0010.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7238d105c145361ef252c35b9d1a9b84138cf2e7919ed919e4fa3b2814ecfe2
+size 1293608960

train/0011.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49293df979e3b56204f1982ce5a42044c16e62d61fed831aac2399f54da87555
+size 1213030400

train/0012.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1d480d584a755db6478973af51b6acf8db20fb040046840f1e10ca6729666b7
+size 1625978880

train/0013.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:861307dab7d2dc88c73bf785ee14b5a7d641b6f9fbfc3f0ae3be70629f8586ea
+size 1930004480

train/0014.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:abc16518cb51cdff5bcf76cb7c84e5019b4e7dffc28c661469e766150ef24bea
+size 2228244480

train/0015.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d08a209f977c38db9c9ad107fad51fdb4ced1f5f77c7592173571334ad9d662
+size 2562600960

train/0016.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e586bed8f3879c5a3b4a09667f3f97b4b43279d5757c3b16e1ee0e272d513caf
+size 2500055040

train/0017.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f7ec2b94641a443687040971eee10eb625549df563cca98478fb79e6ac7345a
+size 2139074560

train/0018.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b303bf168b83dde83bf14e032d3460c74eb30e0433764172022e434b5d45196
+size 2052659200

train/0019.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb7e168b05ed51cc6189aad8c4dfc49421154d5d4db5c30536b47c39d493a7f3
+size 808386560

train/0020.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3917c59fa822eb6abfe320e953918ea20bad36edb9a9582aa73f42dc36e23a26
+size 1050255360

train/0021.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef8f7f053973c1b2a714d892035c224d0b2cb934a5fb657456906f5ae48d8eaa
+size 1269288960

train/0022.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b27d7f8bdd53f909be89729246095275ffc7653d6e3896efa44f0e6eaf1461c
+size 1944053760

train/0023.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7265463ef4084d75c039f8766d82fdb4ce66c3d3f741fa703c28fc5cecdeae78
+size 2260346880

train/0024.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36ee9f7cdc03fb0a1a949548270b974bc49e0df5ef2ebce0bd937b003b08b578
+size 2318325760

train/0025.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e77853970356afadfe2a8d468ac68d89753c8258a00107848a24089a094cc751
+size 2223923200

train/0026.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:022f4c13c3bf9a3010f37b279e68b799bab28554215b102d14273701153cbcd2
+size 379965440