browseraudio 0.1.0__tar.gz

browseraudio-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 browseraudio contributors
+
+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.

browseraudio-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: browseraudio
+Version: 0.1.0
+Summary: Microphone capture for in-browser Python (Pyodide / JupyterLite) via the Web Audio API.
+Author: jiaweil6
+License: MIT
+Project-URL: Homepage, https://github.com/jiaweil6/browseraudio
+Project-URL: Repository, https://github.com/jiaweil6/browseraudio
+Project-URL: Issues, https://github.com/jiaweil6/browseraudio/issues
+Keywords: pyodide,jupyterlite,web audio,microphone,anywidget,wasm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anywidget>=0.9
+Requires-Dist: numpy
+Provides-Extra: pyquist
+Requires-Dist: pyquist; extra == "pyquist"
+Dynamic: license-file
+
+# browseraudio
+
+Microphone capture for **in-browser Python** — Pyodide, JupyterLite, thebe-lite —
+via the browser's Web Audio API.
+
+When Python runs in the browser it usually lives in a **Web Worker**, where the
+Web Audio API and `getUserMedia` don't exist and the DOM is out of reach. So
+the classic audio stack (`sounddevice` → PortAudio) can't run, and libraries
+that depend on it fall back to "not available" stubs. `browseraudio` bridges
+that gap: it captures audio on the browser's **main thread** (through a tiny
+[`anywidget`](https://anywidget.dev) frontend) and hands the samples back to the
+Python kernel over the widget comm channel.
+
+> **Status: v0 — recording only, and a foundation to build on.** The full
+> round-trip is proven end-to-end under thebe-lite (Pyodide 0.27.7): a 1-second
+> capture returned a float32 array, shape `(48000, 1)` at 48 kHz, with real
+> signal. See the roadmap for what's next.
+
+## Install
+
+```sh
+pip install browseraudio          # in a normal environment
+```
+
+In a browser kernel, install at runtime with micropip:
+
+```python
+import micropip
+await micropip.install("browseraudio")
+```
+
+## Use
+
+The recording finishes *after* you click the button, so read the result in a
+**separate cell** from the one that shows the widget:
+
+```python
+from browseraudio import Recorder
+
+rec = Recorder(duration=3.0)
+rec                      # shows a "● Record 3s" button — click it, then speak
+```
+
+After it captures, an inline player appears so you can hear the take. Then,
+**in the next cell**, use the audio:
+
+```python
+rec.samples              # float32 ndarray, shape (n_frames, 1)
+rec.sample_rate          # e.g. 48000
+```
+
+> Why two cells? A single-cell `await record()` can't work in Jupyter/thebe —
+> the kernel doesn't process the widget's reply while that same cell is still
+> running, so the recording would never arrive. Display in one cell, use it in
+> the next.
+
+With [pyquist](https://github.com/gclef-cmu/pyquist) installed, get an `Audio`
+object directly:
+
+```python
+clip = rec.to_pyquist()  # pyquist.Audio
+```
+
+## How it works
+
+```
+ main thread (browser)                         worker (Python kernel)
+ ─────────────────────                         ──────────────────────
+ getUserMedia → AudioContext  ──comm (base64 float32)──►  numpy float32
+ (anywidget frontend)                                     Recorder.samples
+```
+
+The kernel→page direction (displaying the widget) and the page→kernel direction
+(sending samples back) both ride the standard Jupyter widget comm, which works
+in JupyterLite and thebe-lite.
+
+## Roadmap
+
+- **Playback** — push a buffer to a main-thread `AudioContext` (`play`).
+- **AudioWorklet backend** — replace the deprecated `ScriptProcessorNode` used
+  in v0.
+- **sounddevice-compatible facade** — expose `play` / `rec` / `wait` /
+  `query_devices` so a library like pyquist works in the browser **unchanged**
+  (a real `sounddevice` replacement, not a stub).
+- **Streaming** (stretch) — generator → ring buffer → AudioWorklet. Bounded by
+  the browser: Python can't run in the audio thread, and `SharedArrayBuffer`
+  needs cross-origin-isolation (COOP/COEP) headers.
+
+## Caveats
+
+- Recording needs **HTTPS** (or `localhost`), a **user gesture** (the button),
+  and the browser's microphone-permission prompt.
+- v0 transfers samples as base64 over the comm — simple and robust; binary comm
+  buffers would be more efficient.
+- v0 uses `ScriptProcessorNode` (deprecated but universally supported).
+
+## License
+
+MIT

browseraudio-0.1.0/README.md

@@ -0,0 +1,99 @@
+# browseraudio
+
+Microphone capture for **in-browser Python** — Pyodide, JupyterLite, thebe-lite —
+via the browser's Web Audio API.
+
+When Python runs in the browser it usually lives in a **Web Worker**, where the
+Web Audio API and `getUserMedia` don't exist and the DOM is out of reach. So
+the classic audio stack (`sounddevice` → PortAudio) can't run, and libraries
+that depend on it fall back to "not available" stubs. `browseraudio` bridges
+that gap: it captures audio on the browser's **main thread** (through a tiny
+[`anywidget`](https://anywidget.dev) frontend) and hands the samples back to the
+Python kernel over the widget comm channel.
+
+> **Status: v0 — recording only, and a foundation to build on.** The full
+> round-trip is proven end-to-end under thebe-lite (Pyodide 0.27.7): a 1-second
+> capture returned a float32 array, shape `(48000, 1)` at 48 kHz, with real
+> signal. See the roadmap for what's next.
+
+## Install
+
+```sh
+pip install browseraudio          # in a normal environment
+```
+
+In a browser kernel, install at runtime with micropip:
+
+```python
+import micropip
+await micropip.install("browseraudio")
+```
+
+## Use
+
+The recording finishes *after* you click the button, so read the result in a
+**separate cell** from the one that shows the widget:
+
+```python
+from browseraudio import Recorder
+
+rec = Recorder(duration=3.0)
+rec                      # shows a "● Record 3s" button — click it, then speak
+```
+
+After it captures, an inline player appears so you can hear the take. Then,
+**in the next cell**, use the audio:
+
+```python
+rec.samples              # float32 ndarray, shape (n_frames, 1)
+rec.sample_rate          # e.g. 48000
+```
+
+> Why two cells? A single-cell `await record()` can't work in Jupyter/thebe —
+> the kernel doesn't process the widget's reply while that same cell is still
+> running, so the recording would never arrive. Display in one cell, use it in
+> the next.
+
+With [pyquist](https://github.com/gclef-cmu/pyquist) installed, get an `Audio`
+object directly:
+
+```python
+clip = rec.to_pyquist()  # pyquist.Audio
+```
+
+## How it works
+
+```
+ main thread (browser)                         worker (Python kernel)
+ ─────────────────────                         ──────────────────────
+ getUserMedia → AudioContext  ──comm (base64 float32)──►  numpy float32
+ (anywidget frontend)                                     Recorder.samples
+```
+
+The kernel→page direction (displaying the widget) and the page→kernel direction
+(sending samples back) both ride the standard Jupyter widget comm, which works
+in JupyterLite and thebe-lite.
+
+## Roadmap
+
+- **Playback** — push a buffer to a main-thread `AudioContext` (`play`).
+- **AudioWorklet backend** — replace the deprecated `ScriptProcessorNode` used
+  in v0.
+- **sounddevice-compatible facade** — expose `play` / `rec` / `wait` /
+  `query_devices` so a library like pyquist works in the browser **unchanged**
+  (a real `sounddevice` replacement, not a stub).
+- **Streaming** (stretch) — generator → ring buffer → AudioWorklet. Bounded by
+  the browser: Python can't run in the audio thread, and `SharedArrayBuffer`
+  needs cross-origin-isolation (COOP/COEP) headers.
+
+## Caveats
+
+- Recording needs **HTTPS** (or `localhost`), a **user gesture** (the button),
+  and the browser's microphone-permission prompt.
+- v0 transfers samples as base64 over the comm — simple and robust; binary comm
+  buffers would be more efficient.
+- v0 uses `ScriptProcessorNode` (deprecated but universally supported).
+
+## License
+
+MIT

browseraudio-0.1.0/browseraudio/__init__.py

@@ -0,0 +1,16 @@
+"""browseraudio — microphone capture for in-browser Python (Pyodide / JupyterLite).
+
+A small, framework-agnostic bridge from the browser's Web Audio API to Python
+running in a WebAssembly kernel. The kernel often lives in a Web Worker, where
+Web Audio and ``getUserMedia`` are unavailable; this library does the capture
+on the main thread (via an ``anywidget`` frontend) and ships the samples back.
+
+v0: recording only. See the README for the roadmap (playback, an AudioWorklet
+backend, an async ``await record()`` API, and a sounddevice-compatible facade
+so libraries like pyquist work unchanged in the browser).
+"""
+
+from ._recorder import Recorder, record
+
+__all__ = ["Recorder", "record"]
+__version__ = "0.1.0"

browseraudio-0.1.0/browseraudio/_recorder.py

@@ -0,0 +1,93 @@
+"""The microphone Recorder widget."""
+
+from __future__ import annotations
+
+import base64
+import pathlib
+from typing import Optional
+
+import anywidget
+import numpy as np
+import traitlets
+
+_STATIC = pathlib.Path(__file__).parent / "static"
+
+
+class Recorder(anywidget.AnyWidget):
+    """A microphone recorder for in-browser Python (Pyodide / JupyterLite).
+
+    The audio is captured on the browser's main thread (where the Web Audio
+    API and ``getUserMedia`` live) and handed back to the Python kernel — so
+    it works even when the kernel runs in a Web Worker, as it does under
+    JupyterLite and thebe-lite.
+
+    Because the recording finishes *after* you click the button, read the
+    result in a separate cell from the one that displays the widget::
+
+        from browseraudio import Recorder
+        rec = Recorder(duration=3.0)
+        rec                       # shows a "Record" button — click it
+
+        # ...then, in a later cell:
+        rec.samples               # float32 ndarray, shape (n_frames, 1)
+        rec.sample_rate           # e.g. 48000
+
+    Attributes:
+        duration: Length to record, in seconds (default 3.0).
+        sample_rate: The browser AudioContext's rate; set after recording.
+        error: A message if the last attempt failed, else ``None``.
+    """
+
+    _esm = _STATIC / "recorder.js"
+
+    duration = traitlets.Float(3.0).tag(sync=True)
+    sample_rate = traitlets.Int(0).tag(sync=True)
+    # Internal sync state (the transport is base64 float32 over the comm).
+    _pcm_b64 = traitlets.Unicode("").tag(sync=True)
+    _error = traitlets.Unicode("").tag(sync=True)
+
+    def __init__(self, duration: float = 3.0, **kwargs):
+        super().__init__(duration=duration, **kwargs)
+        self._samples: Optional[np.ndarray] = None
+        self.error: Optional[str] = None
+        self.observe(self._on_pcm, names="_pcm_b64")
+        self.observe(self._on_error, names="_error")
+
+    def _on_pcm(self, change) -> None:
+        if not change["new"]:
+            return
+        raw = base64.b64decode(change["new"])
+        # `astype` makes a writable copy (frombuffer is read-only).
+        self._samples = np.frombuffer(raw, dtype="<f4").astype(np.float32).reshape(-1, 1)
+        self.error = None
+
+    def _on_error(self, change) -> None:
+        self.error = change["new"] or None
+
+    @property
+    def samples(self) -> Optional[np.ndarray]:
+        """The most recent recording as float32 ``(n_frames, 1)``, or ``None``."""
+        return self._samples
+
+    def to_pyquist(self):
+        """Return the recording as a :class:`pyquist.Audio` (requires pyquist)."""
+        if self._samples is None:
+            raise RuntimeError("Nothing recorded yet — click Record first.")
+        import pyquist as pq
+
+        return pq.Audio(self._samples, sample_rate=self.sample_rate)
+
+
+def record(duration: float = 3.0) -> Recorder:
+    """Create, display, and return a :class:`Recorder`.
+
+    Click **Record**, then read ``.samples`` (or ``.to_pyquist()``) in a
+    *later* cell. (A single-cell ``await`` flow can't work in Jupyter/thebe:
+    the kernel doesn't process the widget-comm reply while the same cell is
+    still running, so the recording would never arrive — hence two cells.)
+    """
+    from IPython.display import display
+
+    rec = Recorder(duration=duration)
+    display(rec)
+    return rec

browseraudio-0.1.0/browseraudio/static/recorder.js

@@ -0,0 +1,131 @@
+// recorder.js — anywidget frontend for browseraudio.Recorder.
+//
+// Runs on the MAIN thread, where the Web Audio API and getUserMedia live.
+// The Python kernel that drives this widget may be in a Web Worker
+// (JupyterLite / thebe-lite), which has no access to those APIs — so the
+// capture happens here and the samples are handed back to Python over the
+// widget comm channel (base64-encoded float32 PCM). After capturing, an
+// inline <audio> player is shown so the user can hear the take immediately.
+//
+// v0 uses ScriptProcessorNode: deprecated but universally supported and
+// dependency-free. A future version should move to an AudioWorklet.
+
+function toBase64(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  const CHUNK = 0x8000; // chunk to stay under the argument-count limit
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+
+// Encode float32 [-1, 1] mono samples as a 16-bit PCM WAV blob (for the
+// inline preview player only; Python receives the full-precision float32).
+function wavBlob(samples, sampleRate) {
+  const n = samples.length;
+  const buffer = new ArrayBuffer(44 + n * 2);
+  const view = new DataView(buffer);
+  const writeStr = (offset, str) => {
+    for (let i = 0; i < str.length; i++) view.setUint8(offset + i, str.charCodeAt(i));
+  };
+  writeStr(0, "RIFF");
+  view.setUint32(4, 36 + n * 2, true);
+  writeStr(8, "WAVE");
+  writeStr(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true); // PCM
+  view.setUint16(22, 1, true); // mono
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  writeStr(36, "data");
+  view.setUint32(40, n * 2, true);
+  let offset = 44;
+  for (let i = 0; i < n; i++) {
+    const s = Math.max(-1, Math.min(1, samples[i]));
+    view.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+    offset += 2;
+  }
+  return new Blob([buffer], { type: "audio/wav" });
+}
+
+async function render({ model, el }) {
+  const button = document.createElement("button");
+  button.className = "jupyter-button";
+  const status = document.createElement("span");
+  status.style.marginLeft = "0.5em";
+  const player = document.createElement("div"); // holds the inline preview
+  player.style.marginTop = "0.5em";
+
+  const label = () => "● Record " + model.get("duration") + "s";
+  button.textContent = label();
+  model.on("change:duration", () => (button.textContent = label()));
+  el.append(button, status, player);
+
+  button.addEventListener("click", async () => {
+    button.disabled = true;
+    status.textContent = "recording…";
+    player.replaceChildren();
+    let stream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      const AudioCtx = window.AudioContext || window.webkitAudioContext;
+      const ctx = new AudioCtx();
+      await ctx.resume();
+      const sampleRate = ctx.sampleRate;
+      const duration = model.get("duration");
+
+      const source = ctx.createMediaStreamSource(stream);
+      const processor = ctx.createScriptProcessor(4096, 1, 1);
+      const chunks = [];
+      let total = 0;
+
+      await new Promise((resolve) => {
+        processor.onaudioprocess = (event) => {
+          const input = event.inputBuffer.getChannelData(0);
+          chunks.push(new Float32Array(input));
+          total += input.length;
+          if (total >= duration * sampleRate) resolve();
+        };
+        source.connect(processor);
+        processor.connect(ctx.destination);
+        setTimeout(resolve, (duration + 1.5) * 1000); // safety: never hang
+      });
+
+      processor.disconnect();
+      source.disconnect();
+      ctx.close();
+
+      const pcm = new Float32Array(total);
+      let offset = 0;
+      for (const chunk of chunks) {
+        pcm.set(chunk, offset);
+        offset += chunk.length;
+      }
+
+      model.set("sample_rate", sampleRate);
+      model.set("_pcm_b64", total ? toBase64(pcm.buffer) : "");
+      if (!total) model.set("_error", "no audio was captured");
+      model.save_changes();
+      status.textContent = "recorded " + (total / sampleRate).toFixed(2) + "s";
+
+      if (total) {
+        const audio = document.createElement("audio");
+        audio.controls = true;
+        audio.src = URL.createObjectURL(wavBlob(pcm, sampleRate));
+        player.append(audio);
+      }
+    } catch (err) {
+      model.set("_error", String(err));
+      model.save_changes();
+      status.textContent = "error: " + err;
+    } finally {
+      if (stream) stream.getTracks().forEach((t) => t.stop());
+      button.disabled = false;
+    }
+  });
+}
+
+export default { render };

browseraudio-0.1.0/browseraudio.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: browseraudio
+Version: 0.1.0
+Summary: Microphone capture for in-browser Python (Pyodide / JupyterLite) via the Web Audio API.
+Author: jiaweil6
+License: MIT
+Project-URL: Homepage, https://github.com/jiaweil6/browseraudio
+Project-URL: Repository, https://github.com/jiaweil6/browseraudio
+Project-URL: Issues, https://github.com/jiaweil6/browseraudio/issues
+Keywords: pyodide,jupyterlite,web audio,microphone,anywidget,wasm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anywidget>=0.9
+Requires-Dist: numpy
+Provides-Extra: pyquist
+Requires-Dist: pyquist; extra == "pyquist"
+Dynamic: license-file
+
+# browseraudio
+
+Microphone capture for **in-browser Python** — Pyodide, JupyterLite, thebe-lite —
+via the browser's Web Audio API.
+
+When Python runs in the browser it usually lives in a **Web Worker**, where the
+Web Audio API and `getUserMedia` don't exist and the DOM is out of reach. So
+the classic audio stack (`sounddevice` → PortAudio) can't run, and libraries
+that depend on it fall back to "not available" stubs. `browseraudio` bridges
+that gap: it captures audio on the browser's **main thread** (through a tiny
+[`anywidget`](https://anywidget.dev) frontend) and hands the samples back to the
+Python kernel over the widget comm channel.
+
+> **Status: v0 — recording only, and a foundation to build on.** The full
+> round-trip is proven end-to-end under thebe-lite (Pyodide 0.27.7): a 1-second
+> capture returned a float32 array, shape `(48000, 1)` at 48 kHz, with real
+> signal. See the roadmap for what's next.
+
+## Install
+
+```sh
+pip install browseraudio          # in a normal environment
+```
+
+In a browser kernel, install at runtime with micropip:
+
+```python
+import micropip
+await micropip.install("browseraudio")
+```
+
+## Use
+
+The recording finishes *after* you click the button, so read the result in a
+**separate cell** from the one that shows the widget:
+
+```python
+from browseraudio import Recorder
+
+rec = Recorder(duration=3.0)
+rec                      # shows a "● Record 3s" button — click it, then speak
+```
+
+After it captures, an inline player appears so you can hear the take. Then,
+**in the next cell**, use the audio:
+
+```python
+rec.samples              # float32 ndarray, shape (n_frames, 1)
+rec.sample_rate          # e.g. 48000
+```
+
+> Why two cells? A single-cell `await record()` can't work in Jupyter/thebe —
+> the kernel doesn't process the widget's reply while that same cell is still
+> running, so the recording would never arrive. Display in one cell, use it in
+> the next.
+
+With [pyquist](https://github.com/gclef-cmu/pyquist) installed, get an `Audio`
+object directly:
+
+```python
+clip = rec.to_pyquist()  # pyquist.Audio
+```
+
+## How it works
+
+```
+ main thread (browser)                         worker (Python kernel)
+ ─────────────────────                         ──────────────────────
+ getUserMedia → AudioContext  ──comm (base64 float32)──►  numpy float32
+ (anywidget frontend)                                     Recorder.samples
+```
+
+The kernel→page direction (displaying the widget) and the page→kernel direction
+(sending samples back) both ride the standard Jupyter widget comm, which works
+in JupyterLite and thebe-lite.
+
+## Roadmap
+
+- **Playback** — push a buffer to a main-thread `AudioContext` (`play`).
+- **AudioWorklet backend** — replace the deprecated `ScriptProcessorNode` used
+  in v0.
+- **sounddevice-compatible facade** — expose `play` / `rec` / `wait` /
+  `query_devices` so a library like pyquist works in the browser **unchanged**
+  (a real `sounddevice` replacement, not a stub).
+- **Streaming** (stretch) — generator → ring buffer → AudioWorklet. Bounded by
+  the browser: Python can't run in the audio thread, and `SharedArrayBuffer`
+  needs cross-origin-isolation (COOP/COEP) headers.
+
+## Caveats
+
+- Recording needs **HTTPS** (or `localhost`), a **user gesture** (the button),
+  and the browser's microphone-permission prompt.
+- v0 transfers samples as base64 over the comm — simple and robust; binary comm
+  buffers would be more efficient.
+- v0 uses `ScriptProcessorNode` (deprecated but universally supported).
+
+## License
+
+MIT

browseraudio-0.1.0/browseraudio.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+browseraudio/__init__.py
+browseraudio/_recorder.py
+browseraudio.egg-info/PKG-INFO
+browseraudio.egg-info/SOURCES.txt
+browseraudio.egg-info/dependency_links.txt
+browseraudio.egg-info/requires.txt
+browseraudio.egg-info/top_level.txt
+browseraudio/static/recorder.js

browseraudio-0.1.0/browseraudio.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

browseraudio-0.1.0/browseraudio.egg-info/requires.txt

@@ -0,0 +1,5 @@
+anywidget>=0.9
+numpy
+
+[pyquist]
+pyquist

browseraudio-0.1.0/browseraudio.egg-info/top_level.txt

@@ -0,0 +1 @@
+browseraudio

browseraudio-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "browseraudio"
+version = "0.1.0"
+description = "Microphone capture for in-browser Python (Pyodide / JupyterLite) via the Web Audio API."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "jiaweil6" }]
+keywords = ["pyodide", "jupyterlite", "web audio", "microphone", "anywidget", "wasm"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Framework :: Jupyter",
+]
+dependencies = [
+    "anywidget>=0.9",
+    "numpy",
+]
+
+[project.urls]
+Homepage = "https://github.com/jiaweil6/browseraudio"
+Repository = "https://github.com/jiaweil6/browseraudio"
+Issues = "https://github.com/jiaweil6/browseraudio/issues"
+
+[project.optional-dependencies]
+pyquist = ["pyquist"]
+
+[tool.setuptools]
+packages = ["browseraudio"]
+
+[tool.setuptools.package-data]
+browseraudio = ["static/*.js"]

browseraudio-0.1.0/setup.cfg

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