random-looper 0.1.0__tar.gz

random_looper-0.1.0/LICENSE

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

random_looper-0.1.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: random-looper
+Version: 0.1.0
+Summary: Play an audio file forever with randomized, crossfaded loop points.
+Author-email: Your Name <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Lorekeeper49/random-looper
+Keywords: audio,looping,ambient,crossfade,soundfile
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: soundfile>=0.12
+Requires-Dist: sounddevice>=0.4.6
+Provides-Extra: render-only
+Requires-Dist: numpy>=1.21; extra == "render-only"
+Requires-Dist: soundfile>=0.12; extra == "render-only"
+Dynamic: license-file
+
+# Random Looper
+
+Play an audio file forever with **randomized, crossfaded loop points**, and optionally render an extended copy of it to any length you like.
+
+Every time the audio loops, the script picks a brand-new random "jump from" point and "jump to" point, then hides the jump with a crossfade. Because the points change on every loop, the result never repeats in the same way twice.
+
+> ## ⚠️ Read this first: this is for atmosphere, not music
+>
+> This kind of looping only really works for **ambient / atmospheric audio**: rain, wind, ocean waves, forest or jungle ambience, a crackling fire, room tone, crowd murmur, an engine hum, a synth drone, and similar steady textures.
+>
+> It will **not** work well on **music**. Music has rhythm, melody, harmony and structure. Jumping between two random points means:
+>
+> - the beat lands in the wrong place, so the tempo feels like it stumbles,
+> - the chords or key change abruptly or clash,
+> - phrases, lyrics and builds get cut off or repeated mid-thought,
+> - a crossfade between two unrelated musical passages just sounds like two songs playing over each other (muddy, phasing, "mashup" sound).
+>
+> Atmosphere survives this because it has no beat, melody or story. Any 10-second slice sounds much like any other, so a smooth blend between two random slices is nearly invisible.
+>
+> Even with atmosphere, **distinct one-off sounds** (a single bird call, a thunderclap, a door slam, a voice) can end up cut in half, doubled, or repeated suspiciously often. Use `--exclude` (below) to keep loop points away from those moments.
+
+---
+
+## Install
+
+From PyPI:
+
+```Shell
+pip install random-looper
+```
+
+From this repo (editable, for development):
+
+```Shell
+pip install -e .
+```
+
+Once installed you get a `random-looper` command:
+
+```Shell
+random-looper rain.wav
+random-looper ocean.ogg -e 10:00 -o ocean_10min.wav
+```
+
+Or run it as a module:
+
+```Shell
+python -m random_looper rain.wav
+```
+
+## Manual Install
+
+Requires Python 3.8+.
+
+```Shell
+pip install numpy soundfile sounddevice
+```
+
+- `numpy` and `soundfile` are needed for everything.
+- `sounddevice` is only needed for live playback. If you only use `--no-play`, you can skip it.
+- WAV, FLAC and OGG work out of the box. MP3 needs libsndfile 1.1 or newer, which recent `soundfile` wheels include.
+
+Or you can install from `requirements.txt` using `pip install -r requirments.txt`.
+
+If you're on Linux, you also need the PortAudio system library for sounddevice to work, use `sudo apt install libportaudio2` to install it if you haven't already.
+
+---
+
+## Quick start
+
+```Shell
+python random_looper.py rain.wav
+```
+
+Play `rain.wav` forever with random loop points. Press **Ctrl+C** to stop.
+
+```Shell
+python random_looper.py                      # (it asks you for the file path)
+```
+
+```Shell
+python random_looper.py forest.flac -x "[(0,15),(60,75.5)]"
+```
+
+Same, but never choose a loop point in 0-15s or 60-75.5s (for example, to avoid an intro or a loud bird call).
+
+```Shell
+python random_looper.py ocean.ogg -e 10:00 -o ocean_10min.wav
+```
+
+Write a 10-minute version to `ocean_10min.wav`, then play the original with random loops.
+
+```Shell
+python random_looper.py wind.mp3 -e 1:00:00 --no-play
+```
+
+Just write a one-hour file and don't play anything.
+
+---
+
+## Arguments
+
+| Argument                         | Description                                                                                                                                                                                          | Default                                        |
+| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| `audio`                        | Path to the audio file. Optional: if you leave it out, the script prompts you for it. Quotes around the path are fine.                                                                               | prompt                                         |
+| `-x`, `--exclude RANGES`     | Time ranges, in **seconds**, that loop points may not land in. See [Exclusion ranges](#exclusion-ranges).                                                                                       | none                                           |
+| `-e`, `--extend LENGTH`      | Also write an extended copy of the audio of exactly this length. Accepts seconds (`90`, `90.5`) or `mm:ss` / `h:mm:ss` (`10:00`, `1:30:00`).                                             | off                                            |
+| `-o`, `--output PATH`        | Where to write the extended file. The format comes from the extension (`.wav`, `.flac`, `.ogg`...). Only used with `--extend`.                                                               | `<name>_extended.wav` next to the input file |
+| `--no-play`                    | Don't play anything. Useful with `--extend` to just make the file.                                                                                                                                 | off (plays)                                    |
+| `--no-log`                     | Don't print the startup info line or the loop points while playing.                                                                                                                                  | off (prints)                                   |
+| `-c`, `--crossfade SECONDS`  | Length of the crossfade used to hide each jump.                                                                                                                                                      | `2.0`                                        |
+| `-m`, `--min-length SECONDS` | Minimum amount of audio **played before each jump** and **inside each loop** (the distance between the jump-to and jump-from points). Larger values mean longer stretches between jumps. | `10.0`                                       |
+| `--fade-out SECONDS`           | Length of the fade-out at the very end of the extended file. Capped at a quarter of the extended length. Only used with `--extend`.                                                                | `4.0`                                        |
+| `--seed N`                     | Seed the random number generator so you get the same sequence of loop points every run.                                                                                                              | random                                         |
+
+### Automatic adjustments for short files
+
+So that short files don't break the algorithm, the script clamps your settings:
+
+- crossfade is limited to 1/8 of the file length (and is at least 0.05 s),
+- min-length is limited to 1/3 of the file length, but never less than twice the crossfade.
+
+If it changes your values, it prints the values it used.
+
+### Exclusion ranges
+
+`-x` takes a Python-style list of `(start, end)` pairs in seconds:
+
+```Shell
+-x "[(0, 15), (60, 75.5)]"
+```
+
+- Wrap it in quotes so your shell/command prompt doesn't mangle the brackets and commas.
+- A single pair works too: `-x "(0,15)"`.
+- Overlapping ranges are merged, and a pair given backwards (`(20,10)`) is flipped.
+- The ranges apply to **both** loop points: the point it jumps **from** and the point it jumps **to**. Neither will ever be picked inside an excluded range.
+- Playback itself can still pass through excluded areas on its way. They are only off-limits as loop points.
+- The crossfade window sits just *before* each loop point, so a crossfade can still overlap the edge of an excluded range. If that matters, make the range a little bigger.
+- If your exclusions leave too little room for a loop (for example, you excluded almost the whole file), the script stops with an error telling you to shrink them or lower `--min-length` / `--crossfade`.
+
+---
+
+## How it works
+
+1. **Load.** The file is decoded into memory as 32-bit float audio.
+2. **Plan a jump.** For every loop the script picks a random pair of points, **B** (where it jumps *from*) and **A** (where it jumps *to*), with A earlier than B. The picks are uniform over all the allowed time (everything not excluded), and always satisfy:
+   - neither point is inside an excluded range,
+   - at least `--min-length` seconds play before the jump,
+   - at least `--min-length` seconds sit between A and B,
+   - A is at least one crossfade length into the file (there has to be audio before it to fade in),
+   - a valid next jump always exists, so the script can never paint itself into a corner.
+3. **Crossfade.** The audio just before B (the last `--crossfade` seconds) fades out while the audio just before A fades in, using an **equal-power** curve so the volume stays steady through the blend. When the crossfade finishes, playback continues from A as if nothing happened.
+4. **Repeat.** Playback continues to the next randomly chosen B, jumps back to a new random A, and so on forever. The first pass starts at the beginning of the file.
+
+### Playback
+
+A background thread prepares audio in pieces (the normal stretch, then the crossfaded jump, and so on) and feeds a small queue. The sound card callback just copies from that queue, so the heavy lifting never happens in the audio thread. Each time a jump starts, a line like this is printed (unless `--no-log` is set):
+
+```
+  loop: 2:14.30 -> 0:45.20
+```
+
+That means "jumped from 2:14.30 back to 0:45.20".
+
+### Extended file
+
+With `--extend`, the same jump logic is run offline and streamed straight to disk, so even very long outputs don't need to fit in memory. The file is trimmed to exactly the length you asked for and ends with a fade-out (`--fade-out`). A progress percentage is shown while it renders. After rendering, the script plays the original unless you pass `--no-play`.
+
+Output is 16-bit PCM for WAV by default. Samples are clipped to the valid range, since an equal-power crossfade of very similar loud audio can briefly exceed full scale.
+
+---
+
+## Tips for good results
+
+- Pick **steady, texture-like** recordings with no obvious beginning, end or repeating pattern.
+- If the source has a fade-in, fade-out, or a distinct event you don't want repeated or chopped, cover it with `--exclude`.
+- Longer `--crossfade` (3-6 s) hides jumps better on very smooth sounds like drones. Shorter is fine for noisy textures like rain.
+- A larger `--min-length` makes the loop feel slower and more natural; a smaller one means more frequent (but still smooth) jumps.
+- Use `--seed` if you find a render you like and want to reproduce it.
+- Very short source files give the randomizer little to work with, and repetition becomes easy to notice. Longer recordings (a minute or more) work best.
+
+---
+
+## Troubleshooting
+
+| Problem                                           | Fix                                                                                                       |
+| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `Playback needs sounddevice`                    | `pip install sounddevice`                                                                               |
+| `File not found`                                | Check the path. Put quotes around paths with spaces.                                                      |
+| `Could not read audio file`                     | The format may not be supported by your libsndfile build. Convert the file to WAV or FLAC.                |
+| `Could not parse --exclude`                     | Use the form `"[(10, 20), (45.5, 60)]"`, with the quotes.                                               |
+| `The exclusion ranges leave too little room...` | Shrink the exclusions, or lower `--min-length` / `--crossfade`.                                       |
+| Audible clicks or stutters in playback            | Your machine may be too busy to keep the audio queue filled. Close other heavy programs.                  |
+| Jumps sound obvious                               | The source is probably not stationary enough. See the warning at the top about music and distinct sounds. |

random_looper-0.1.0/README.md

@@ -0,0 +1,194 @@
+# Random Looper
+
+Play an audio file forever with **randomized, crossfaded loop points**, and optionally render an extended copy of it to any length you like.
+
+Every time the audio loops, the script picks a brand-new random "jump from" point and "jump to" point, then hides the jump with a crossfade. Because the points change on every loop, the result never repeats in the same way twice.
+
+> ## ⚠️ Read this first: this is for atmosphere, not music
+>
+> This kind of looping only really works for **ambient / atmospheric audio**: rain, wind, ocean waves, forest or jungle ambience, a crackling fire, room tone, crowd murmur, an engine hum, a synth drone, and similar steady textures.
+>
+> It will **not** work well on **music**. Music has rhythm, melody, harmony and structure. Jumping between two random points means:
+>
+> - the beat lands in the wrong place, so the tempo feels like it stumbles,
+> - the chords or key change abruptly or clash,
+> - phrases, lyrics and builds get cut off or repeated mid-thought,
+> - a crossfade between two unrelated musical passages just sounds like two songs playing over each other (muddy, phasing, "mashup" sound).
+>
+> Atmosphere survives this because it has no beat, melody or story. Any 10-second slice sounds much like any other, so a smooth blend between two random slices is nearly invisible.
+>
+> Even with atmosphere, **distinct one-off sounds** (a single bird call, a thunderclap, a door slam, a voice) can end up cut in half, doubled, or repeated suspiciously often. Use `--exclude` (below) to keep loop points away from those moments.
+
+---
+
+## Install
+
+From PyPI:
+
+```Shell
+pip install random-looper
+```
+
+From this repo (editable, for development):
+
+```Shell
+pip install -e .
+```
+
+Once installed you get a `random-looper` command:
+
+```Shell
+random-looper rain.wav
+random-looper ocean.ogg -e 10:00 -o ocean_10min.wav
+```
+
+Or run it as a module:
+
+```Shell
+python -m random_looper rain.wav
+```
+
+## Manual Install
+
+Requires Python 3.8+.
+
+```Shell
+pip install numpy soundfile sounddevice
+```
+
+- `numpy` and `soundfile` are needed for everything.
+- `sounddevice` is only needed for live playback. If you only use `--no-play`, you can skip it.
+- WAV, FLAC and OGG work out of the box. MP3 needs libsndfile 1.1 or newer, which recent `soundfile` wheels include.
+
+Or you can install from `requirements.txt` using `pip install -r requirments.txt`.
+
+If you're on Linux, you also need the PortAudio system library for sounddevice to work, use `sudo apt install libportaudio2` to install it if you haven't already.
+
+---
+
+## Quick start
+
+```Shell
+python random_looper.py rain.wav
+```
+
+Play `rain.wav` forever with random loop points. Press **Ctrl+C** to stop.
+
+```Shell
+python random_looper.py                      # (it asks you for the file path)
+```
+
+```Shell
+python random_looper.py forest.flac -x "[(0,15),(60,75.5)]"
+```
+
+Same, but never choose a loop point in 0-15s or 60-75.5s (for example, to avoid an intro or a loud bird call).
+
+```Shell
+python random_looper.py ocean.ogg -e 10:00 -o ocean_10min.wav
+```
+
+Write a 10-minute version to `ocean_10min.wav`, then play the original with random loops.
+
+```Shell
+python random_looper.py wind.mp3 -e 1:00:00 --no-play
+```
+
+Just write a one-hour file and don't play anything.
+
+---
+
+## Arguments
+
+| Argument                         | Description                                                                                                                                                                                          | Default                                        |
+| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| `audio`                        | Path to the audio file. Optional: if you leave it out, the script prompts you for it. Quotes around the path are fine.                                                                               | prompt                                         |
+| `-x`, `--exclude RANGES`     | Time ranges, in **seconds**, that loop points may not land in. See [Exclusion ranges](#exclusion-ranges).                                                                                       | none                                           |
+| `-e`, `--extend LENGTH`      | Also write an extended copy of the audio of exactly this length. Accepts seconds (`90`, `90.5`) or `mm:ss` / `h:mm:ss` (`10:00`, `1:30:00`).                                             | off                                            |
+| `-o`, `--output PATH`        | Where to write the extended file. The format comes from the extension (`.wav`, `.flac`, `.ogg`...). Only used with `--extend`.                                                               | `<name>_extended.wav` next to the input file |
+| `--no-play`                    | Don't play anything. Useful with `--extend` to just make the file.                                                                                                                                 | off (plays)                                    |
+| `--no-log`                     | Don't print the startup info line or the loop points while playing.                                                                                                                                  | off (prints)                                   |
+| `-c`, `--crossfade SECONDS`  | Length of the crossfade used to hide each jump.                                                                                                                                                      | `2.0`                                        |
+| `-m`, `--min-length SECONDS` | Minimum amount of audio **played before each jump** and **inside each loop** (the distance between the jump-to and jump-from points). Larger values mean longer stretches between jumps. | `10.0`                                       |
+| `--fade-out SECONDS`           | Length of the fade-out at the very end of the extended file. Capped at a quarter of the extended length. Only used with `--extend`.                                                                | `4.0`                                        |
+| `--seed N`                     | Seed the random number generator so you get the same sequence of loop points every run.                                                                                                              | random                                         |
+
+### Automatic adjustments for short files
+
+So that short files don't break the algorithm, the script clamps your settings:
+
+- crossfade is limited to 1/8 of the file length (and is at least 0.05 s),
+- min-length is limited to 1/3 of the file length, but never less than twice the crossfade.
+
+If it changes your values, it prints the values it used.
+
+### Exclusion ranges
+
+`-x` takes a Python-style list of `(start, end)` pairs in seconds:
+
+```Shell
+-x "[(0, 15), (60, 75.5)]"
+```
+
+- Wrap it in quotes so your shell/command prompt doesn't mangle the brackets and commas.
+- A single pair works too: `-x "(0,15)"`.
+- Overlapping ranges are merged, and a pair given backwards (`(20,10)`) is flipped.
+- The ranges apply to **both** loop points: the point it jumps **from** and the point it jumps **to**. Neither will ever be picked inside an excluded range.
+- Playback itself can still pass through excluded areas on its way. They are only off-limits as loop points.
+- The crossfade window sits just *before* each loop point, so a crossfade can still overlap the edge of an excluded range. If that matters, make the range a little bigger.
+- If your exclusions leave too little room for a loop (for example, you excluded almost the whole file), the script stops with an error telling you to shrink them or lower `--min-length` / `--crossfade`.
+
+---
+
+## How it works
+
+1. **Load.** The file is decoded into memory as 32-bit float audio.
+2. **Plan a jump.** For every loop the script picks a random pair of points, **B** (where it jumps *from*) and **A** (where it jumps *to*), with A earlier than B. The picks are uniform over all the allowed time (everything not excluded), and always satisfy:
+   - neither point is inside an excluded range,
+   - at least `--min-length` seconds play before the jump,
+   - at least `--min-length` seconds sit between A and B,
+   - A is at least one crossfade length into the file (there has to be audio before it to fade in),
+   - a valid next jump always exists, so the script can never paint itself into a corner.
+3. **Crossfade.** The audio just before B (the last `--crossfade` seconds) fades out while the audio just before A fades in, using an **equal-power** curve so the volume stays steady through the blend. When the crossfade finishes, playback continues from A as if nothing happened.
+4. **Repeat.** Playback continues to the next randomly chosen B, jumps back to a new random A, and so on forever. The first pass starts at the beginning of the file.
+
+### Playback
+
+A background thread prepares audio in pieces (the normal stretch, then the crossfaded jump, and so on) and feeds a small queue. The sound card callback just copies from that queue, so the heavy lifting never happens in the audio thread. Each time a jump starts, a line like this is printed (unless `--no-log` is set):
+
+```
+  loop: 2:14.30 -> 0:45.20
+```
+
+That means "jumped from 2:14.30 back to 0:45.20".
+
+### Extended file
+
+With `--extend`, the same jump logic is run offline and streamed straight to disk, so even very long outputs don't need to fit in memory. The file is trimmed to exactly the length you asked for and ends with a fade-out (`--fade-out`). A progress percentage is shown while it renders. After rendering, the script plays the original unless you pass `--no-play`.
+
+Output is 16-bit PCM for WAV by default. Samples are clipped to the valid range, since an equal-power crossfade of very similar loud audio can briefly exceed full scale.
+
+---
+
+## Tips for good results
+
+- Pick **steady, texture-like** recordings with no obvious beginning, end or repeating pattern.
+- If the source has a fade-in, fade-out, or a distinct event you don't want repeated or chopped, cover it with `--exclude`.
+- Longer `--crossfade` (3-6 s) hides jumps better on very smooth sounds like drones. Shorter is fine for noisy textures like rain.
+- A larger `--min-length` makes the loop feel slower and more natural; a smaller one means more frequent (but still smooth) jumps.
+- Use `--seed` if you find a render you like and want to reproduce it.
+- Very short source files give the randomizer little to work with, and repetition becomes easy to notice. Longer recordings (a minute or more) work best.
+
+---
+
+## Troubleshooting
+
+| Problem                                           | Fix                                                                                                       |
+| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `Playback needs sounddevice`                    | `pip install sounddevice`                                                                               |
+| `File not found`                                | Check the path. Put quotes around paths with spaces.                                                      |
+| `Could not read audio file`                     | The format may not be supported by your libsndfile build. Convert the file to WAV or FLAC.                |
+| `Could not parse --exclude`                     | Use the form `"[(10, 20), (45.5, 60)]"`, with the quotes.                                               |
+| `The exclusion ranges leave too little room...` | Shrink the exclusions, or lower `--min-length` / `--crossfade`.                                       |
+| Audible clicks or stutters in playback            | Your machine may be too busy to keep the audio queue filled. Close other heavy programs.                  |
+| Jumps sound obvious                               | The source is probably not stationary enough. See the warning at the top about music and distinct sounds. |

random_looper-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "random-looper"
+version = "0.1.0"
+description = "Play an audio file forever with randomized, crossfaded loop points."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }              # change or remove if you prefer
+authors = [{ name = "Your Name", email = "you@example.com" }]
+keywords = ["audio", "looping", "ambient", "crossfade", "soundfile"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Environment :: Console",
+]
+dependencies = [
+    "numpy>=1.21",
+    "soundfile>=0.12",
+    "sounddevice>=0.4.6",
+]
+
+[project.optional-dependencies]
+# For people who only ever use --no-play and don't want PortAudio installed:
+render-only = ["numpy>=1.21", "soundfile>=0.12"]
+
+[project.scripts]
+random-looper = "random_looper.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/Lorekeeper49/random-looper"
+
+[tool.setuptools.packages.find]
+where = ["src"]

random_looper-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

random_looper-0.1.0/src/random_looper/__init__.py

@@ -0,0 +1,6 @@
+"""random_looper — play audio with randomized, crossfaded loop points."""
+
+from .__main__ import main
+
+__version__ = "0.1.0"
+__all__ = ["main", "__version__"]

random_looper-0.1.0/src/random_looper/__main__.py

@@ -0,0 +1,349 @@
+#!/usr/bin/env python3
+"""
+random_looper.py - endlessly play an audio file with randomized, crossfaded loop points.
+
+Every loop, a new (loop_from, loop_to) pair is chosen at random. The jump is hidden by an
+equal-power crossfade: the last moments before `loop_from` fade out while the moments just
+before `loop_to` fade in, then playback carries on from `loop_to`.
+
+Optionally:
+  * exclude time ranges (seconds) from being chosen as loop points
+  * render an extended copy of the audio to a desired length
+
+Install:
+    pip install numpy soundfile sounddevice
+
+Examples:
+    python random_looper.py song.wav
+    python random_looper.py song.flac -x "[(0,15),(60,75.5)]"
+    python random_looper.py song.ogg -e 10:00 -o song_10min.wav
+    python random_looper.py song.mp3 -e 1:00:00 --no-play
+    python random_looper.py                      (prompts for the file path)
+
+Notes:
+    * Exclusion ranges are in seconds and apply to BOTH loop points (the jump-from point
+      and the jump-to point). The crossfade window sits just before each point.
+    * Reading mp3 needs libsndfile >= 1.1 (bundled with recent `soundfile` wheels).
+"""
+import argparse
+import ast
+import queue
+import random
+import sys
+import threading
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import numpy as np
+import soundfile as sf
+
+EPS = 1e-6
+Span = Tuple[float, float]
+
+
+# --------------------------------------------------------------------------- helpers
+def parse_time(text) -> float:
+    """'90', '90.5', '1:30', '1:02:03' -> seconds."""
+    total = 0.0
+    for part in str(text).strip().split(":"):
+        total = total * 60 + float(part)
+    return total
+
+
+def fmt(t: float) -> str:
+    m, s = divmod(t, 60)
+    return f"{int(m)}:{s:05.2f}"
+
+
+def parse_exclusions(text: Optional[str]) -> List[Span]:
+    """Parse "[(start, end), (start, end)]" (seconds) into merged, sorted spans."""
+    if not text:
+        return []
+    try:
+        val = ast.literal_eval(text)
+        if (isinstance(val, tuple) and len(val) == 2
+                and all(isinstance(v, (int, float)) for v in val)):
+            val = [val]  # a single (start, end) pair
+        spans = []
+        for a, b in val:
+            a, b = float(a), float(b)
+            spans.append((min(a, b), max(a, b)))
+    except (ValueError, SyntaxError, TypeError):
+        sys.exit('Could not parse --exclude. Use the form: "[(10, 20), (45.5, 60)]"')
+    spans.sort()
+    merged: List[Span] = []
+    for a, b in spans:
+        if merged and a <= merged[-1][1]:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], b))
+        else:
+            merged.append((a, b))
+    return merged
+
+
+def allowed_intervals(lo: float, hi: float, excl: List[Span]) -> List[Span]:
+    """[lo, hi] minus the excluded spans."""
+    spans = [(lo, hi)] if hi - lo > EPS else []
+    for ex_a, ex_b in excl:
+        out = []
+        for a, b in spans:
+            if ex_b <= a or ex_a >= b:
+                out.append((a, b))
+                continue
+            if ex_a > a:
+                out.append((a, ex_a))
+            if ex_b < b:
+                out.append((ex_b, b))
+        spans = [(a, b) for a, b in out if b - a > EPS]
+    return spans
+
+
+def clip_spans(spans: List[Span], lo: float, hi: float) -> List[Span]:
+    out = []
+    for a, b in spans:
+        a2, b2 = max(a, lo), min(b, hi)
+        if b2 - a2 > EPS:
+            out.append((a2, b2))
+    return out
+
+
+def sample_uniform(spans: List[Span], rng: random.Random) -> float:
+    total = sum(b - a for a, b in spans)
+    r = rng.uniform(0, total)
+    for a, b in spans:
+        if r <= b - a:
+            return a + r
+        r -= b - a
+    return spans[-1][1]
+
+
+# --------------------------------------------------------------------------- loop logic
+class LoopPlanner:
+    """
+    Picks random (loop_to, loop_from) pairs that always:
+      * avoid the excluded ranges,
+      * leave at least `min_len` seconds of playing before the jump and inside the loop,
+      * leave room for a crossfade before the loop_to point,
+      * never paint themselves into a corner (a valid next jump always exists).
+    """
+
+    def __init__(self, duration: float, crossfade: float, min_len: float,
+                 excl: List[Span], rng: random.Random):
+        self.cf, self.min_len, self.rng = crossfade, min_len, rng
+        self.a_spans = allowed_intervals(crossfade, duration, excl)  # valid loop_to points
+        self.b_spans = allowed_intervals(0.0, duration, excl)        # valid loop_from points
+        if not self.a_spans or not self.b_spans:
+            raise ValueError("The exclusion ranges cover the whole file.")
+        self.a_min = self.a_spans[0][0]
+        self.b_max = self.b_spans[-1][1]
+        if self.b_max - self.a_min <= min_len + EPS:
+            raise ValueError(
+                "The exclusion ranges leave too little room for a loop "
+                f"(need more than {min_len:.1f}s between the earliest and latest allowed points). "
+                "Shrink the exclusions or lower --min-length / --crossfade.")
+
+    def next_pair(self, pos: float) -> Tuple[float, float]:
+        """Given current play position (s), return (loop_to A, loop_from B) with A < B."""
+        lo = max(pos + self.min_len, self.a_min + self.min_len)
+        b_spans = clip_spans(self.b_spans, lo, self.b_max)
+        if not b_spans:
+            raise RuntimeError("No valid loop point found.")
+        b = sample_uniform(b_spans, self.rng)
+        a_hi = min(b - self.min_len, self.b_max - self.min_len)
+        a_spans = clip_spans(self.a_spans, self.cf, a_hi)
+        if not a_spans:
+            raise RuntimeError("No valid loop point found.")
+        a = sample_uniform(a_spans, self.rng)
+        return a, b
+
+
+@dataclass
+class Piece:
+    data: np.ndarray          # (frames, channels) float32
+    label: Optional[str] = None
+
+
+def loop_stream(audio: np.ndarray, sr: int, planner: LoopPlanner, crossfade: float):
+    """Infinite generator of Pieces: body, crossfaded jump, body, crossfaded jump, ..."""
+    n = len(audio)
+    c = max(1, int(round(crossfade * sr)))
+    t = np.linspace(0.0, 1.0, c, dtype=np.float32)
+    fade_out = np.cos(t * np.pi / 2)[:, None]   # equal-power curves
+    fade_in = np.sin(t * np.pi / 2)[:, None]
+    pos = 0
+    while True:
+        a_s, b_s = planner.next_pair(pos / sr)
+        a = max(c, int(round(a_s * sr)))
+        b = min(n, int(round(b_s * sr)))
+        yield Piece(audio[pos:b - c])
+        xfade = audio[b - c:b] * fade_out + audio[a - c:a] * fade_in
+        yield Piece(np.clip(xfade, -1.0, 1.0).astype(np.float32),
+                    f"loop: {fmt(b / sr)} -> {fmt(a / sr)}")
+        pos = a
+
+
+# --------------------------------------------------------------------------- extended file
+def render_extended(audio, sr, planner, crossfade, target_sec, fade_sec, out_path: Path):
+    """Stream an extended version of the audio to disk (exactly target_sec long)."""
+    channels = audio.shape[1]
+    target = int(round(target_sec * sr))
+    fade_n = min(int(round(fade_sec * sr)), target // 4)
+    body_limit = target - fade_n
+    written = 0
+    tail: List[np.ndarray] = []
+    tail_len = 0
+    loops = 0
+    last_print = 0.0
+
+    with sf.SoundFile(str(out_path), "w", samplerate=sr, channels=channels) as out:
+        for piece in loop_stream(audio, sr, planner, crossfade):
+            d = piece.data
+            if piece.label:
+                loops += 1
+            if written < body_limit:
+                take = min(len(d), body_limit - written)
+                out.write(d[:take])
+                written += take
+                d = d[take:]
+            if len(d):
+                tail.append(d)
+                tail_len += len(d)
+            if written >= body_limit and tail_len >= fade_n:
+                break
+            now = time.time()
+            if now - last_print > 0.5:
+                pct = 100 * (written + tail_len) / target
+                print(f"\r  rendering... {pct:5.1f}%", end="", flush=True)
+                last_print = now
+        if fade_n:
+            end = np.concatenate(tail)[:fade_n]
+            end = end * np.linspace(1.0, 0.0, fade_n, dtype=np.float32)[:, None]
+            out.write(end)
+    print(f"\r  rendered {fmt(target_sec)} with {loops} loop jumps -> {out_path}      ")
+
+
+# --------------------------------------------------------------------------- playback
+def play(audio, sr, planner, crossfade, log=True):
+    try:
+        import sounddevice as sd
+    except ImportError:
+        sys.exit("Playback needs sounddevice:  pip install sounddevice")
+
+    channels = audio.shape[1]
+    q: "queue.Queue[Piece]" = queue.Queue(maxsize=4)
+    logq: "queue.Queue[str]" = queue.Queue()
+    stop = threading.Event()
+    state = {"cur": None, "off": 0}
+
+    def producer():
+        for piece in loop_stream(audio, sr, planner, crossfade):
+            while not stop.is_set():
+                try:
+                    q.put(piece, timeout=0.2)
+                    break
+                except queue.Full:
+                    continue
+            if stop.is_set():
+                return
+
+    def callback(outdata, frames, time_info, status):
+        filled = 0
+        while filled < frames:
+            cur = state["cur"]
+            if cur is None or state["off"] >= len(cur):
+                try:
+                    piece = q.get_nowait()
+                except queue.Empty:
+                    outdata[filled:] = 0
+                    return
+                state["cur"], state["off"] = piece.data, 0
+                if piece.label:
+                    logq.put(piece.label)
+                continue
+            take = min(frames - filled, len(cur) - state["off"])
+            outdata[filled:filled + take] = cur[state["off"]:state["off"] + take]
+            state["off"] += take
+            filled += take
+
+    threading.Thread(target=producer, daemon=True).start()
+    print("Playing. Press Ctrl+C to stop.")
+    try:
+        with sd.OutputStream(samplerate=sr, channels=channels, dtype="float32",
+                             callback=callback, blocksize=2048):
+            while True:
+                try:
+                    msg = logq.get(timeout=0.2)
+                    if log:
+                        print(" ", msg)
+                except queue.Empty:
+                    pass
+    except KeyboardInterrupt:
+        print("\nStopped.")
+    finally:
+        stop.set()
+
+
+# --------------------------------------------------------------------------- main
+def main():
+    p = argparse.ArgumentParser(description="Play audio with random crossfaded loop points.")
+    p.add_argument("audio", nargs="?", help="audio file (prompted for if omitted)")
+    p.add_argument("-x", "--exclude", metavar="RANGES",
+                   help='seconds to exclude from loop points, e.g. "[(0,15),(60,75.5)]"')
+    p.add_argument("-e", "--extend", metavar="LENGTH",
+                   help="also write an extended file of this length (seconds, or mm:ss / h:mm:ss)")
+    p.add_argument("-o", "--output", help="extended file path (default: <name>_extended.wav)")
+    p.add_argument("--no-play", action="store_true", help="skip playback (just write the file)")
+    p.add_argument("--no-log", action="store_true", help="skip logging loop points to stdout")
+    p.add_argument("-c", "--crossfade", type=float, default=2.0,
+                   help="crossfade length in seconds (default 2)")
+    p.add_argument("-m", "--min-length", type=float, default=10.0,
+                   help="minimum seconds of audio between jumps / inside a loop (default 10)")
+    p.add_argument("--fade-out", type=float, default=4.0,
+                   help="fade-out at the end of the extended file, seconds (default 4)")
+    p.add_argument("--seed", type=int, help="random seed (for repeatable results)")
+    args = p.parse_args()
+
+    path = args.audio or input("Audio file path: ").strip().strip('"').strip("'")
+    if not Path(path).is_file():
+        sys.exit(f"File not found: {path}")
+
+    try:
+        audio, sr = sf.read(path, dtype="float32", always_2d=True)
+    except Exception as e:  # noqa: BLE001
+        sys.exit(f"Could not read audio file: {e}")
+    duration = len(audio) / sr
+
+    # Keep settings sane for short files.
+    cf = max(0.05, min(args.crossfade, duration / 8))
+    min_len = max(2 * cf, min(args.min_length, duration / 3))
+    if (cf, min_len) != (args.crossfade, args.min_length):
+        print(f"Adjusted for file length: crossfade={cf:.2f}s, min-length={min_len:.2f}s")
+
+    excl = parse_exclusions(args.exclude)
+    rng = random.Random(args.seed)
+    try:
+        planner = LoopPlanner(duration, cf, min_len, excl, rng)
+    except ValueError as e:
+        sys.exit(str(e))
+
+    if not args.no_log:
+        print(f"Loaded {Path(path).name}: {fmt(duration)}, {sr} Hz, {audio.shape[1]} ch"
+              + (f", excluding {excl}" if excl else ""))
+
+    if args.extend:
+        target = parse_time(args.extend)
+        if target <= 0:
+            sys.exit("--extend must be positive.")
+        out_path = Path(args.output) if args.output else \
+            Path(path).with_name(Path(path).stem + "_extended.wav")
+        render_extended(audio, sr, planner, cf, target, args.fade_out, out_path)
+
+    if not args.no_play:
+        # fresh planner so playback isn't affected by the render
+        play(audio, sr, LoopPlanner(duration, cf, min_len, excl, rng), cf,
+             log=not args.no_log)
+
+
+if __name__ == "__main__":
+    main()

random_looper-0.1.0/src/random_looper.egg-info/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: random-looper
+Version: 0.1.0
+Summary: Play an audio file forever with randomized, crossfaded loop points.
+Author-email: Your Name <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Lorekeeper49/random-looper
+Keywords: audio,looping,ambient,crossfade,soundfile
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: soundfile>=0.12
+Requires-Dist: sounddevice>=0.4.6
+Provides-Extra: render-only
+Requires-Dist: numpy>=1.21; extra == "render-only"
+Requires-Dist: soundfile>=0.12; extra == "render-only"
+Dynamic: license-file
+
+# Random Looper
+
+Play an audio file forever with **randomized, crossfaded loop points**, and optionally render an extended copy of it to any length you like.
+
+Every time the audio loops, the script picks a brand-new random "jump from" point and "jump to" point, then hides the jump with a crossfade. Because the points change on every loop, the result never repeats in the same way twice.
+
+> ## ⚠️ Read this first: this is for atmosphere, not music
+>
+> This kind of looping only really works for **ambient / atmospheric audio**: rain, wind, ocean waves, forest or jungle ambience, a crackling fire, room tone, crowd murmur, an engine hum, a synth drone, and similar steady textures.
+>
+> It will **not** work well on **music**. Music has rhythm, melody, harmony and structure. Jumping between two random points means:
+>
+> - the beat lands in the wrong place, so the tempo feels like it stumbles,
+> - the chords or key change abruptly or clash,
+> - phrases, lyrics and builds get cut off or repeated mid-thought,
+> - a crossfade between two unrelated musical passages just sounds like two songs playing over each other (muddy, phasing, "mashup" sound).
+>
+> Atmosphere survives this because it has no beat, melody or story. Any 10-second slice sounds much like any other, so a smooth blend between two random slices is nearly invisible.
+>
+> Even with atmosphere, **distinct one-off sounds** (a single bird call, a thunderclap, a door slam, a voice) can end up cut in half, doubled, or repeated suspiciously often. Use `--exclude` (below) to keep loop points away from those moments.
+
+---
+
+## Install
+
+From PyPI:
+
+```Shell
+pip install random-looper
+```
+
+From this repo (editable, for development):
+
+```Shell
+pip install -e .
+```
+
+Once installed you get a `random-looper` command:
+
+```Shell
+random-looper rain.wav
+random-looper ocean.ogg -e 10:00 -o ocean_10min.wav
+```
+
+Or run it as a module:
+
+```Shell
+python -m random_looper rain.wav
+```
+
+## Manual Install
+
+Requires Python 3.8+.
+
+```Shell
+pip install numpy soundfile sounddevice
+```
+
+- `numpy` and `soundfile` are needed for everything.
+- `sounddevice` is only needed for live playback. If you only use `--no-play`, you can skip it.
+- WAV, FLAC and OGG work out of the box. MP3 needs libsndfile 1.1 or newer, which recent `soundfile` wheels include.
+
+Or you can install from `requirements.txt` using `pip install -r requirments.txt`.
+
+If you're on Linux, you also need the PortAudio system library for sounddevice to work, use `sudo apt install libportaudio2` to install it if you haven't already.
+
+---
+
+## Quick start
+
+```Shell
+python random_looper.py rain.wav
+```
+
+Play `rain.wav` forever with random loop points. Press **Ctrl+C** to stop.
+
+```Shell
+python random_looper.py                      # (it asks you for the file path)
+```
+
+```Shell
+python random_looper.py forest.flac -x "[(0,15),(60,75.5)]"
+```
+
+Same, but never choose a loop point in 0-15s or 60-75.5s (for example, to avoid an intro or a loud bird call).
+
+```Shell
+python random_looper.py ocean.ogg -e 10:00 -o ocean_10min.wav
+```
+
+Write a 10-minute version to `ocean_10min.wav`, then play the original with random loops.
+
+```Shell
+python random_looper.py wind.mp3 -e 1:00:00 --no-play
+```
+
+Just write a one-hour file and don't play anything.
+
+---
+
+## Arguments
+
+| Argument                         | Description                                                                                                                                                                                          | Default                                        |
+| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| `audio`                        | Path to the audio file. Optional: if you leave it out, the script prompts you for it. Quotes around the path are fine.                                                                               | prompt                                         |
+| `-x`, `--exclude RANGES`     | Time ranges, in **seconds**, that loop points may not land in. See [Exclusion ranges](#exclusion-ranges).                                                                                       | none                                           |
+| `-e`, `--extend LENGTH`      | Also write an extended copy of the audio of exactly this length. Accepts seconds (`90`, `90.5`) or `mm:ss` / `h:mm:ss` (`10:00`, `1:30:00`).                                             | off                                            |
+| `-o`, `--output PATH`        | Where to write the extended file. The format comes from the extension (`.wav`, `.flac`, `.ogg`...). Only used with `--extend`.                                                               | `<name>_extended.wav` next to the input file |
+| `--no-play`                    | Don't play anything. Useful with `--extend` to just make the file.                                                                                                                                 | off (plays)                                    |
+| `--no-log`                     | Don't print the startup info line or the loop points while playing.                                                                                                                                  | off (prints)                                   |
+| `-c`, `--crossfade SECONDS`  | Length of the crossfade used to hide each jump.                                                                                                                                                      | `2.0`                                        |
+| `-m`, `--min-length SECONDS` | Minimum amount of audio **played before each jump** and **inside each loop** (the distance between the jump-to and jump-from points). Larger values mean longer stretches between jumps. | `10.0`                                       |
+| `--fade-out SECONDS`           | Length of the fade-out at the very end of the extended file. Capped at a quarter of the extended length. Only used with `--extend`.                                                                | `4.0`                                        |
+| `--seed N`                     | Seed the random number generator so you get the same sequence of loop points every run.                                                                                                              | random                                         |
+
+### Automatic adjustments for short files
+
+So that short files don't break the algorithm, the script clamps your settings:
+
+- crossfade is limited to 1/8 of the file length (and is at least 0.05 s),
+- min-length is limited to 1/3 of the file length, but never less than twice the crossfade.
+
+If it changes your values, it prints the values it used.
+
+### Exclusion ranges
+
+`-x` takes a Python-style list of `(start, end)` pairs in seconds:
+
+```Shell
+-x "[(0, 15), (60, 75.5)]"
+```
+
+- Wrap it in quotes so your shell/command prompt doesn't mangle the brackets and commas.
+- A single pair works too: `-x "(0,15)"`.
+- Overlapping ranges are merged, and a pair given backwards (`(20,10)`) is flipped.
+- The ranges apply to **both** loop points: the point it jumps **from** and the point it jumps **to**. Neither will ever be picked inside an excluded range.
+- Playback itself can still pass through excluded areas on its way. They are only off-limits as loop points.
+- The crossfade window sits just *before* each loop point, so a crossfade can still overlap the edge of an excluded range. If that matters, make the range a little bigger.
+- If your exclusions leave too little room for a loop (for example, you excluded almost the whole file), the script stops with an error telling you to shrink them or lower `--min-length` / `--crossfade`.
+
+---
+
+## How it works
+
+1. **Load.** The file is decoded into memory as 32-bit float audio.
+2. **Plan a jump.** For every loop the script picks a random pair of points, **B** (where it jumps *from*) and **A** (where it jumps *to*), with A earlier than B. The picks are uniform over all the allowed time (everything not excluded), and always satisfy:
+   - neither point is inside an excluded range,
+   - at least `--min-length` seconds play before the jump,
+   - at least `--min-length` seconds sit between A and B,
+   - A is at least one crossfade length into the file (there has to be audio before it to fade in),
+   - a valid next jump always exists, so the script can never paint itself into a corner.
+3. **Crossfade.** The audio just before B (the last `--crossfade` seconds) fades out while the audio just before A fades in, using an **equal-power** curve so the volume stays steady through the blend. When the crossfade finishes, playback continues from A as if nothing happened.
+4. **Repeat.** Playback continues to the next randomly chosen B, jumps back to a new random A, and so on forever. The first pass starts at the beginning of the file.
+
+### Playback
+
+A background thread prepares audio in pieces (the normal stretch, then the crossfaded jump, and so on) and feeds a small queue. The sound card callback just copies from that queue, so the heavy lifting never happens in the audio thread. Each time a jump starts, a line like this is printed (unless `--no-log` is set):
+
+```
+  loop: 2:14.30 -> 0:45.20
+```
+
+That means "jumped from 2:14.30 back to 0:45.20".
+
+### Extended file
+
+With `--extend`, the same jump logic is run offline and streamed straight to disk, so even very long outputs don't need to fit in memory. The file is trimmed to exactly the length you asked for and ends with a fade-out (`--fade-out`). A progress percentage is shown while it renders. After rendering, the script plays the original unless you pass `--no-play`.
+
+Output is 16-bit PCM for WAV by default. Samples are clipped to the valid range, since an equal-power crossfade of very similar loud audio can briefly exceed full scale.
+
+---
+
+## Tips for good results
+
+- Pick **steady, texture-like** recordings with no obvious beginning, end or repeating pattern.
+- If the source has a fade-in, fade-out, or a distinct event you don't want repeated or chopped, cover it with `--exclude`.
+- Longer `--crossfade` (3-6 s) hides jumps better on very smooth sounds like drones. Shorter is fine for noisy textures like rain.
+- A larger `--min-length` makes the loop feel slower and more natural; a smaller one means more frequent (but still smooth) jumps.
+- Use `--seed` if you find a render you like and want to reproduce it.
+- Very short source files give the randomizer little to work with, and repetition becomes easy to notice. Longer recordings (a minute or more) work best.
+
+---
+
+## Troubleshooting
+
+| Problem                                           | Fix                                                                                                       |
+| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `Playback needs sounddevice`                    | `pip install sounddevice`                                                                               |
+| `File not found`                                | Check the path. Put quotes around paths with spaces.                                                      |
+| `Could not read audio file`                     | The format may not be supported by your libsndfile build. Convert the file to WAV or FLAC.                |
+| `Could not parse --exclude`                     | Use the form `"[(10, 20), (45.5, 60)]"`, with the quotes.                                               |
+| `The exclusion ranges leave too little room...` | Shrink the exclusions, or lower `--min-length` / `--crossfade`.                                       |
+| Audible clicks or stutters in playback            | Your machine may be too busy to keep the audio queue filled. Close other heavy programs.                  |
+| Jumps sound obvious                               | The source is probably not stationary enough. See the warning at the top about music and distinct sounds. |

random_looper-0.1.0/src/random_looper.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/random_looper/__init__.py
+src/random_looper/__main__.py
+src/random_looper.egg-info/PKG-INFO
+src/random_looper.egg-info/SOURCES.txt
+src/random_looper.egg-info/dependency_links.txt
+src/random_looper.egg-info/entry_points.txt
+src/random_looper.egg-info/requires.txt
+src/random_looper.egg-info/top_level.txt

random_looper-0.1.0/src/random_looper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

random_looper-0.1.0/src/random_looper.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+random-looper = random_looper.__main__:main

random_looper-0.1.0/src/random_looper.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy>=1.21
+soundfile>=0.12
+sounddevice>=0.4.6
+
+[render-only]
+numpy>=1.21
+soundfile>=0.12

random_looper-0.1.0/src/random_looper.egg-info/top_level.txt

@@ -0,0 +1 @@
+random_looper