random-tone-generator 0.0.1__tar.gz

random_tone_generator-0.0.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: random_tone_generator
+Version: 0.0.1
+Summary: Random sweep/hold tone generator with explicit-duration playback.
+Author: Sithu Ye Htun
+License: MIT
+Project-URL: Homepage, https://github.com/leo007-htun/random_tone_generator
+Project-URL: Repository, https://github.com/leo007-htun/random_tone_generator
+Project-URL: Issues, https://github.com/leo007-htun/random_tone_generator/issues
+Keywords: audio,tone,signal,generator,sweep,sound
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: sounddevice>=0.4.6
+
+# random_tone_generator
+
+A small Python utility to generate randomized tone sweeps and holds in real time.
+
+## Features
+
+- Real-time audio output via `sounddevice`
+- Random sweep patterns:
+  - `base -> random -> base`
+  - `base -> random -> random -> base`
+- Adjustable:
+  - playback speed
+  - min/max frequency
+  - amplitude
+- Explicit playback duration with `play_for(seconds)`
+
+## function calls
+gen.set_speed(speed)         # float, must be > 0
+gen.set_max_freq(max_freq)   # float, must be >= min_freq
+gen.set_min_freq(min_freq)   # float, must be <= max_freq   (if implemented)
+gen.set_base_freq(base_freq) # float                        (if implemented)
+gen.set_amplitude(amplitude) # float in [0.0, 1.0]         (if implemented)
+state = gen.get_state()      # returns dict of current settings
+gen.play_for(seconds)        # play for N seconds (explicit mode)
+
+---
+
+## Installation
+
+```bash
+pip install random_tone_generator
+
+
+

random_tone_generator-0.0.1/README.md

@@ -0,0 +1,34 @@
+# random_tone_generator
+
+A small Python utility to generate randomized tone sweeps and holds in real time.
+
+## Features
+
+- Real-time audio output via `sounddevice`
+- Random sweep patterns:
+  - `base -> random -> base`
+  - `base -> random -> random -> base`
+- Adjustable:
+  - playback speed
+  - min/max frequency
+  - amplitude
+- Explicit playback duration with `play_for(seconds)`
+
+## function calls
+gen.set_speed(speed)         # float, must be > 0
+gen.set_max_freq(max_freq)   # float, must be >= min_freq
+gen.set_min_freq(min_freq)   # float, must be <= max_freq   (if implemented)
+gen.set_base_freq(base_freq) # float                        (if implemented)
+gen.set_amplitude(amplitude) # float in [0.0, 1.0]         (if implemented)
+state = gen.get_state()      # returns dict of current settings
+gen.play_for(seconds)        # play for N seconds (explicit mode)
+
+---
+
+## Installation
+
+```bash
+pip install random_tone_generator
+
+
+

random_tone_generator-0.0.1/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "random_tone_generator"
+version = "0.0.1"
+description = "Random sweep/hold tone generator with explicit-duration playback."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+  { name = "Sithu Ye Htun" }
+]
+keywords = ["audio", "tone", "signal", "generator", "sweep", "sound"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Multimedia :: Sound/Audio"
+]
+dependencies = [
+  "numpy>=1.23",
+  "sounddevice>=0.4.6"
+]
+
+[project.urls]
+Homepage = "https://github.com/leo007-htun/random_tone_generator"
+Repository = "https://github.com/leo007-htun/random_tone_generator"
+Issues = "https://github.com/leo007-htun/random_tone_generator/issues"
+
+[tool.setuptools]
+py-modules = ["random_tone_generator"]
+
+[tool.setuptools.packages.find]
+where = ["."]

random_tone_generator-0.0.1/random_tone_generator.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: random_tone_generator
+Version: 0.0.1
+Summary: Random sweep/hold tone generator with explicit-duration playback.
+Author: Sithu Ye Htun
+License: MIT
+Project-URL: Homepage, https://github.com/leo007-htun/random_tone_generator
+Project-URL: Repository, https://github.com/leo007-htun/random_tone_generator
+Project-URL: Issues, https://github.com/leo007-htun/random_tone_generator/issues
+Keywords: audio,tone,signal,generator,sweep,sound
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: sounddevice>=0.4.6
+
+# random_tone_generator
+
+A small Python utility to generate randomized tone sweeps and holds in real time.
+
+## Features
+
+- Real-time audio output via `sounddevice`
+- Random sweep patterns:
+  - `base -> random -> base`
+  - `base -> random -> random -> base`
+- Adjustable:
+  - playback speed
+  - min/max frequency
+  - amplitude
+- Explicit playback duration with `play_for(seconds)`
+
+## function calls
+gen.set_speed(speed)         # float, must be > 0
+gen.set_max_freq(max_freq)   # float, must be >= min_freq
+gen.set_min_freq(min_freq)   # float, must be <= max_freq   (if implemented)
+gen.set_base_freq(base_freq) # float                        (if implemented)
+gen.set_amplitude(amplitude) # float in [0.0, 1.0]         (if implemented)
+state = gen.get_state()      # returns dict of current settings
+gen.play_for(seconds)        # play for N seconds (explicit mode)
+
+---
+
+## Installation
+
+```bash
+pip install random_tone_generator
+
+
+

random_tone_generator-0.0.1/random_tone_generator.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+random_tone_generator.py
+random_tone_generator.egg-info/PKG-INFO
+random_tone_generator.egg-info/SOURCES.txt
+random_tone_generator.egg-info/dependency_links.txt
+random_tone_generator.egg-info/requires.txt
+random_tone_generator.egg-info/top_level.txt

random_tone_generator-0.0.1/random_tone_generator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

random_tone_generator-0.0.1/random_tone_generator.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=1.23
+sounddevice>=0.4.6

random_tone_generator-0.0.1/random_tone_generator.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+random_tone_generator

random_tone_generator-0.0.1/random_tone_generator.py

@@ -0,0 +1,148 @@
+import random
+import numpy as np
+import sounddevice as sd
+
+
+class RandomToneGenerator:
+    def __init__(
+        self,
+        sample_rate=44100,
+        base_freq=100.0,
+        min_freq=100.0,
+        max_freq=8000.0,
+        amplitude=0.2,
+        speed=1.0,
+        base_sweep_min=0.04,
+        base_sweep_max=0.25,
+        base_hold_min=0.00,
+        base_hold_max=0.05,
+        min_duration_floor=0.003,
+    ):
+        self.sample_rate = sample_rate
+        self.base_freq = float(base_freq)
+        self.min_freq = float(min_freq)
+        self.max_freq = float(max_freq)
+        self.amplitude = float(amplitude)
+        self.speed = float(speed)
+
+        self.base_sweep_min = float(base_sweep_min)
+        self.base_sweep_max = float(base_sweep_max)
+        self.base_hold_min = float(base_hold_min)
+        self.base_hold_max = float(base_hold_max)
+        self.min_duration_floor = float(min_duration_floor)
+
+        self._phase = 0.0
+
+    def set_speed(self, speed: float):
+        if speed <= 0:
+            raise ValueError("speed must be > 0")
+        self.speed = float(speed)
+
+    def set_max_freq(self, max_freq: float):
+        if max_freq < self.min_freq:
+            raise ValueError("max_freq must be >= min_freq")
+        self.max_freq = float(max_freq)
+
+    def get_state(self):
+        return {
+            "base_freq": self.base_freq,
+            "min_freq": self.min_freq,
+            "max_freq": self.max_freq,
+            "amplitude": self.amplitude,
+            "speed": self.speed,
+        }
+
+    def _scaled_times(self):
+        sweep_min = max(self.min_duration_floor, self.base_sweep_min / self.speed)
+        sweep_max = max(self.min_duration_floor, self.base_sweep_max / self.speed)
+        hold_min = max(0.0, self.base_hold_min / self.speed)
+        hold_max = max(0.0, self.base_hold_max / self.speed)
+        return sweep_min, sweep_max, hold_min, hold_max
+
+    def _sweep(self, f0, f1, dur):
+        n = max(1, int(self.sample_rate * dur))
+        freq_curve = np.linspace(f0, f1, n, endpoint=False)
+        phase_inc = 2 * np.pi * freq_curve / self.sample_rate
+        phase_curve = self._phase + np.cumsum(phase_inc)
+        y = self.amplitude * np.sin(phase_curve)
+
+        fade_len = min(256, n // 8)
+        if fade_len > 1:
+            fade = np.linspace(0, 1, fade_len)
+            y[:fade_len] *= fade
+            y[-fade_len:] *= fade[::-1]
+
+        self._phase = float(phase_curve[-1] % (2 * np.pi))
+        return y.astype(np.float32)
+
+    def _hold(self, f, dur):
+        n = max(1, int(self.sample_rate * dur))
+        phase_inc = 2 * np.pi * f / self.sample_rate
+        phase_curve = self._phase + phase_inc * np.arange(1, n + 1)
+        y = self.amplitude * np.sin(phase_curve)
+        self._phase = float(phase_curve[-1] % (2 * np.pi))
+        return y.astype(np.float32)
+
+    def _write(self, stream, block):
+        stream.write(block.reshape(-1, 1))
+
+    def play_for(self, seconds: float):
+        """
+        Plays only for `seconds`, then returns.
+        Pattern:
+          1) 100 -> rand -> 100
+          2) 100 -> rand -> rand -> 100
+        """
+        if seconds <= 0:
+            return
+
+        sweep_min, sweep_max, hold_min, hold_max = self._scaled_times()
+
+        elapsed = 0.0
+        with sd.OutputStream(samplerate=self.sample_rate, channels=1, dtype="float32") as stream:
+            while elapsed < seconds:
+                # Pattern 1
+                a = random.uniform(self.min_freq, self.max_freq)
+
+                d = random.uniform(sweep_min, sweep_max)
+                b = self._sweep(self.base_freq, a, d); self._write(stream, b); elapsed += d
+                if elapsed >= seconds: break
+
+                h = random.uniform(hold_min, hold_max)
+                if h > 0:
+                    b = self._hold(a, h); self._write(stream, b); elapsed += h
+                    if elapsed >= seconds: break
+
+                d = random.uniform(sweep_min, sweep_max)
+                b = self._sweep(a, self.base_freq, d); self._write(stream, b); elapsed += d
+                if elapsed >= seconds: break
+
+                h = random.uniform(hold_min, hold_max)
+                if h > 0:
+                    b = self._hold(self.base_freq, h); self._write(stream, b); elapsed += h
+                    if elapsed >= seconds: break
+
+                # Pattern 2
+                bfreq = random.uniform(self.min_freq, self.max_freq)
+                cfreq = random.uniform(self.min_freq, self.max_freq)
+
+                d = random.uniform(sweep_min, sweep_max)
+                b = self._sweep(self.base_freq, bfreq, d); self._write(stream, b); elapsed += d
+                if elapsed >= seconds: break
+
+                h = random.uniform(hold_min, hold_max)
+                if h > 0:
+                    b = self._hold(bfreq, h); self._write(stream, b); elapsed += h
+                    if elapsed >= seconds: break
+
+                d = random.uniform(sweep_min, sweep_max)
+                b = self._sweep(bfreq, cfreq, d); self._write(stream, b); elapsed += d
+                if elapsed >= seconds: break
+
+                h = random.uniform(hold_min, hold_max)
+                if h > 0:
+                    b = self._hold(cfreq, h); self._write(stream, b); elapsed += h
+                    if elapsed >= seconds: break
+
+                d = random.uniform(sweep_min, sweep_max)
+                b = self._sweep(cfreq, self.base_freq, d); self._write(stream, b); elapsed += d

random_tone_generator-0.0.1/setup.cfg

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