recs 0.3.1__tar.gz → 0.10.0__tar.gz

{recs-0.3.1 → recs-0.10.0}/PKG-INFO

@@ -1,30 +1,31 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: recs
-Version: 0.3.1
-Summary: 🎙 recs: the Universal Recorder 🎙
-License: MIT
+Version: 0.10.0
+Summary: 🎙 The Universal Recorder 🎙
 Author: Tom Ritchford
-Author-email: tom@swirly.com
-Requires-Python: >=3.10
-Classifier: License :: OSI Approved :: MIT License
+Author-email: Tom Ritchford <tom@swirly.com>
+License-Expression: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: coverage
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: dtyper
-Requires-Dist: humanfriendly
-Requires-Dist: impall
 Requires-Dist: numpy
-Requires-Dist: overrides
 Requires-Dist: pyaudio
 Requires-Dist: rich
 Requires-Dist: sounddevice
 Requires-Dist: soundfile
+Requires-Dist: threa>=1.9.0
+Requires-Dist: typer
+Requires-Dist: impall
+Requires-Dist: overrides
+Requires-Dist: coverage
 Requires-Dist: strenum
-Requires-Dist: threa (>=1.9.0)
+Requires-Dist: humanfriendly
 Requires-Dist: tomli
-Requires-Dist: typer
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 #  🎬 recs: the Universal Recorder 🎬
@@ -138,4 +139,3 @@ detect if a  device goes offline and report it.
 The holy grail is reconnecting to a device that comes back online: this is an
 [unsolved problem](https://github.com/spatialaudio/python-sounddevice/issues/382)
 in Python, I believe, but I am on my way to solving it.
-

recs-0.10.0/pyproject.toml

@@ -0,0 +1,67 @@
+[project]
+name = "recs"
+version = "0.10.0"
+description = "🎙 The Universal Recorder 🎙"
+authors = [{ name = "Tom Ritchford", email = "tom@swirly.com" }]
+requires-python = ">=3.10"
+readme = "README.md"
+license = "MIT"
+classifiers = ["Programming Language :: Python :: 3", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14"]
+dependencies = [
+    "dtyper",
+    "numpy",
+    "pyaudio",
+    "rich",
+    "sounddevice",
+    "soundfile",
+    "threa>=1.9.0",
+    "typer",
+    "impall",
+    "overrides",
+    "coverage",
+    "strenum",
+    "humanfriendly",
+    "tomli",
+]
+
+[project.scripts]
+recs = "recs.base.cli:run"
+
+[dependency-groups]
+dev = [
+    "coverage>=7.4.1",
+    "pytest",
+    "pyupgrade>=3.21.2",
+    "ruff",
+    "tdir",
+    "ty>=0.0.14",
+]
+
+[tool.uv]
+
+[tool.uv.build-backend]
+module-root = ""
+
+[build-system]
+requires = ["uv_build>=0.9.0,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.coverage.run]
+branch = true
+source = ["recs"]
+omit = [
+    "recs/__main__.py",
+    "recs/cfg/cli.py",
+    "recs/cfg/app.py",
+]
+
+[tool.coverage.report]
+fail_under = 91
+skip_covered = true
+exclude_lines = ["pragma: no cover", "if False:", "if __name__ == .__main__.:", "raise NotImplementedError"]
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.format]
+quote-style = "single"

{recs-0.3.1 → recs-0.10.0}/recs/audio/block.py

@@ -1,3 +1,5 @@
+# mypy: disable-error-code="no-any-return, type-arg"
+
 import dataclasses as dc
 import numbers
 import typing as t
@@ -5,6 +7,8 @@ from functools import cached_property
 
 import numpy as np
 
+from recs.cfg.source import to_matrix
+
 _EMPTY_SEEN = False
 
 
@@ -15,9 +19,7 @@ class Block:
     def __post_init__(self) -> None:
         if not self.block.size:
             raise ValueError('Empty block')
-
-        if len(self.block.shape) == 1:
-            self.__dict__['block'] = self.block.reshape(*self.block.shape, 1)
+        self.__dict__['block'] = to_matrix(self.block)
 
     def __len__(self) -> int:
         return self.block.shape[0]
@@ -26,7 +28,7 @@ class Block:
         return Block(self.block[index])
 
     @cached_property
-    def is_float(self):
+    def is_float(self) -> bool:
         return not issubclass(self.block.dtype.type, numbers.Integral)
 
     @cached_property

recs-0.10.0/recs/audio/channel_writer.py

@@ -0,0 +1,238 @@
+import contextlib
+import sys
+import typing as t
+from datetime import datetime
+from pathlib import Path
+from threading import Lock
+
+from numpy.typing import NDArray
+from overrides import override
+from soundfile import SoundFile
+from threa import Runnable
+
+from recs.base.state import ChannelState
+from recs.base.type_conversions import SUBTYPE_TO_SDTYPE
+from recs.base.types import SDTYPE, Active, Format, SdType
+from recs.cfg import Cfg, Track, time_settings
+from recs.misc import counter, file_list
+
+from .block import Block, Blocks
+from .file_opener import FileOpener
+from .header_size import header_size
+
+URL = 'https://github.com/rec/recs'
+
+BUFFER = 0x80
+MAX_WAV_SIZE = 0x1_0000_0000 - BUFFER
+
+ITEMSIZE = {
+    SdType.float32: 4,
+    SdType.int16: 2,
+    SdType.int32: 4,
+}
+
+BLOCK_FUZZ = 2
+
+
+class ChannelWriter(Runnable):
+    bytes_in_file: int = 0
+
+    frames_in_file: int = 0
+    frames_written: int = 0  # Used elsewhere
+
+    largest_file_size: int = 0
+    longest_file_frames: int = 0
+
+    timestamp: float = 0
+
+    _sfs: t.Sequence[SoundFile] = ()
+
+    @property
+    def active(self) -> Active:
+        return Active.active if self._sfs else Active.inactive
+
+    def __init__(
+        self, cfg: Cfg, times: time_settings.TimeSettings[int], track: Track
+    ) -> None:
+        super().__init__()
+
+        self.cfg = cfg
+        self.do_not_record = cfg.dry_run or cfg.calibrate
+        self.metadata = cfg.metadata
+        self.times = times
+        self.track = track
+
+        self._blocks = Blocks()
+        self._lock = Lock()
+
+        if track.source.format is None or cfg.cfg.formats:
+            self.formats = cfg.formats
+        else:
+            self.formats = [track.source.format]
+
+        if track.source.subtype is None or cfg.cfg.subtype:
+            subtype = cfg.subtype
+        else:
+            subtype = track.source.subtype
+
+        if track.source.subtype is None or cfg.cfg.sdtype:
+            sdtype = cfg.sdtype or SDTYPE
+        else:
+            sdtype = SUBTYPE_TO_SDTYPE[track.source.subtype]
+
+        self.files_written = file_list.FileList()
+        self.frame_size = ITEMSIZE[sdtype] * len(track.channels)
+        self.longest_file_frames = times.longest_file_time
+
+        self.openers = [
+            FileOpener(
+                channels=len(track.channels),
+                format=f,
+                samplerate=track.source.samplerate,
+                subtype=subtype,
+            )
+            for f in self.formats
+        ]
+        self._volume = counter.MovingBlock(times.moving_average_time)
+
+        def size(f: str) -> int:
+            return (
+                MAX_WAV_SIZE if f == Format.wav and not self.cfg.infinite_length else 0
+            )
+
+        self.largest_file_size = max(0, *(size(f) for f in cfg.formats))
+
+    def to_block(self, array: NDArray) -> Block:
+        return Block(array[:, self.track.slice])
+
+    def receive_update(
+        self, block: Block, timestamp: float, should_record: bool = False
+    ) -> ChannelState:
+        with self._lock:
+            should_record = should_record or self.should_record(block)
+            return self._receive_block(block, timestamp, should_record)
+
+    def should_record(self, block: Block) -> bool:
+        return (
+            self.times.record_everything
+            or block.volume >= self.times.noise_floor_amplitude
+        )
+
+    @override
+    def stop(self) -> None:
+        with self._lock:
+            self.running = False
+            self._write_and_close()
+            self.stopped = True
+
+    def _close(self) -> None:
+        sfs, self._sfs = self._sfs, ()
+        for sf in sfs:
+            if sf.frames and sf.frames >= self.times.shortest_file_time:
+                print(sf.name, file=sys.stderr)
+                sf.close()
+            else:
+                with contextlib.suppress(Exception):
+                    sf.close()
+                with contextlib.suppress(Exception):
+                    Path(sf.name).unlink()
+
+    def _open(self, offset: int) -> t.Sequence[SoundFile]:
+        timestamp = self.timestamp - offset / self.track.source.samplerate
+        date = datetime.fromtimestamp(timestamp).isoformat()
+        index = 1 + len(self.files_written)
+        metadata = {'date': date, 'software': URL, 'tracknumber': str(index)}
+        metadata |= self.metadata
+
+        self.bytes_in_file = max(header_size(metadata, f) for f in self.cfg.formats)
+        self.frames_in_file = 0
+
+        path = self.cfg.output_directory.make_path(
+            self.track, self.cfg.aliases, timestamp, index
+        )
+        sfs = [o.create(metadata, path) for o in self.openers]
+        self.files_written.extend(Path(sf.name) for sf in sfs)
+        return sfs
+
+    def _receive_block(
+        self, block: Block, timestamp: float, should_record: bool
+    ) -> ChannelState:
+        saved_state = self._state(
+            max_amp=max(block.max) / block.scale,
+            min_amp=min(block.min) / block.scale,
+        )
+
+        dt = self.timestamp - timestamp
+        self.timestamp = timestamp
+        self._volume(block)
+
+        if not self.do_not_record and (self._sfs or not self.stopped):
+            expected_dt = len(block) / self.track.source.samplerate
+
+            if dt > expected_dt * BLOCK_FUZZ:  # We were asleep, or otherwise lost time
+                self._write_and_close()
+
+            self._blocks.append(block)
+
+            if should_record:
+                if not self._sfs:  # Record some quiet before the first block
+                    length = self.times.quiet_before_start + len(self._blocks[-1])
+                    self._blocks.clip(length, from_start=True)
+
+                self._write_blocks(self._blocks)
+                self._blocks.clear()
+
+            if self.stopped or self._blocks.duration > self.times.stop_after_quiet:
+                self._write_and_close()
+
+        return self._state() - saved_state
+
+    def _state(self, **kwargs: t.Any) -> ChannelState:
+        return ChannelState(
+            file_count=len(self.files_written),
+            file_size=self.files_written.total_size,
+            is_active=bool(self._sfs),
+            recorded_time=self.frames_written / self.track.source.samplerate,
+            timestamp=self.timestamp,
+            volume=tuple(self._volume.mean()),
+            **kwargs,
+        )
+
+    def _write_and_close(self) -> None:
+        # Record some quiet after the last block
+        removed = self._blocks.clip(self.times.quiet_after_end, from_start=False)
+
+        if self._sfs and removed:
+            self._write_blocks(reversed(removed))
+
+        self._close()
+
+    def _write_blocks(self, blox: t.Iterable[Block]) -> None:
+        blocks = list(blox)
+
+        # The last block in the list ends at self.timestamp so
+        # we keep track of the sample offset before that
+        offset = -sum(len(b) for b in blocks)
+
+        for b in blocks:
+            # Check if this block will overrun the file size or length
+            remains: list[int] = []
+
+            if self.longest_file_frames:
+                remains.append(self.longest_file_frames - self.frames_in_file)
+
+            if self._sfs and self.largest_file_size:
+                file_bytes = self.largest_file_size - self.bytes_in_file
+                remains.append(file_bytes // self.frame_size)
+
+            if remains and min(remains) <= len(b):
+                self._close()
+
+            self._sfs = self._sfs or self._open(offset)
+            for sf in self._sfs:
+                sf.write(b.block)
+            offset += len(b)
+
+            self.frames_in_file += len(b)
+            self.frames_written += len(b)
+            self.bytes_in_file += len(b) * self.frame_size

recs-0.10.0/recs/audio/file_opener.py

@@ -0,0 +1,50 @@
+import dataclasses as dc
+import itertools
+import typing as t
+from pathlib import Path
+
+import soundfile
+
+from recs.base.types import Format, Subtype
+from recs.cfg.metadata import ALLOWS_METADATA
+
+
+@dc.dataclass
+class FileOpener:
+    format: Format
+    channels: int = 1
+    samplerate: int = 48_000
+    subtype: Subtype | None = None
+
+    def open(
+        self, path: Path | str, metadata: t.Mapping[str, str], overwrite: bool = False
+    ) -> soundfile.SoundFile:
+        path = Path(path).with_suffix('.' + self.format)
+        if not overwrite and path.exists():
+            raise FileExistsError(str(path))
+
+        fp = soundfile.SoundFile(
+            channels=self.channels,
+            file=path,
+            format=self.format,
+            mode='w',
+            samplerate=self.samplerate,
+            subtype=self.subtype,
+        )
+
+        if self.format in ALLOWS_METADATA:
+            for k, v in metadata.items():
+                setattr(fp, k, v)
+
+        return fp
+
+    def create(self, metadata: t.Mapping[str, str], path: Path) -> soundfile.SoundFile:
+        path.parent.mkdir(exist_ok=True, parents=True)
+
+        for i in itertools.count():
+            f = path.parent / (path.name + bool(i) * f'_{i}')
+            try:
+                return self.open(f, metadata)
+            except FileExistsError:
+                pass
+        raise FileNotFoundError

{recs-0.3.1 → recs-0.10.0}/recs/audio/header_size.py

@@ -1,15 +1,15 @@
+import typing as t
+
 from recs.base.types import Format
 
 
-def header_size(metadata: dict[str, str], format: Format) -> int:
-    tag = 9
-    if format == Format.aiff:
-        base, first, software = 54, 0, 22
-    elif format == Format.wav:
-        base, first, software = 44, 12, 19
-    else:
+def header_size(metadata: t.Mapping[str, str], format: Format) -> int:
+    if format != Format.wav:
         return 0
 
+    tag = 9
+    base, first, software = 44, 12, 19
+
     values = (software * (k == 'software') + tag + len(v) for k, v in metadata.items())
     values = (v + v % 2 for v in values)
 

{recs-0.3.1 → recs-0.10.0}/recs/base/_query_device.py

@@ -8,14 +8,14 @@ import json
 import typing as t
 
 
-def query_devices() -> list[dict[str, t.Any]]:
+def _query_devices() -> t.Any:
     try:
         import sounddevice
 
         return sounddevice.query_devices()
-    except Exception:
+    except BaseException:
         return []
 
 
 if __name__ == '__main__':
-    print(json.dumps(query_devices(), indent=4))
+    print(json.dumps(_query_devices(), indent=4))

{recs-0.3.1 → recs-0.10.0}/recs/base/cfg_raw.py

@@ -2,8 +2,6 @@ import dataclasses as dc
 import typing as t
 from pathlib import Path
 
-from .types import Format
-
 
 @dc.dataclass
 class CfgRaw:
@@ -11,7 +9,8 @@ class CfgRaw:
     #
     # Directory settings
     #
-    path: str = ''
+    files: list[str] = dc.field(default_factory=list)
+    output_directory: str = ''
     #
     # General purpose settings
     #
@@ -33,7 +32,7 @@ class CfgRaw:
     #
     # Audio file format and subtype
     #
-    format: str = Format.flac
+    formats: t.Sequence[str] = ()
     metadata: t.Sequence[str] = ()
     sdtype: str = ''
     subtype: str = ''
@@ -47,10 +46,12 @@ class CfgRaw:
     #
     # Settings relating to times
     #
+    band_mode: bool = True
     infinite_length: bool = False
     longest_file_time: float = 0.0
     moving_average_time: float = 1.0
     noise_floor: float = 70.0
+    record_everything: bool = False
     shortest_file_time: float = 1.0
     quiet_after_end: float = 2.0
     quiet_before_start: float = 1.0

{recs-0.3.1 → recs-0.10.0}/recs/base/pyproject.py

@@ -7,7 +7,7 @@ assert PYPROJECT.exists()
 
 
 def message() -> str:
-    p = tomli.loads(PYPROJECT.read_text())['tool']['poetry']
+    p = tomli.loads(PYPROJECT.read_text())['project']
     desc, name = p['description'], p['name']
 
     icon, *d, icon2 = desc.split()

{recs-0.3.1 → recs-0.10.0}/recs/base/type_conversions.py

@@ -11,16 +11,7 @@ SUBTYPE_TO_SDTYPE = {
     Subtype.alac_24: SdType.int32,
     Subtype.alac_32: SdType.int32,
     Subtype.double: SdType.float32,
-    Subtype.dpcm_16: SdType.int16,
-    Subtype.dpcm_8: SdType.int16,
-    Subtype.dwvw_12: SdType.int16,
-    Subtype.dwvw_16: SdType.int16,
-    Subtype.dwvw_24: SdType.int32,
     Subtype.float: SdType.float32,
-    Subtype.ms_adpcm: SdType.int32,
-    Subtype.nms_adpcm_16: SdType.int16,
-    Subtype.nms_adpcm_24: SdType.int32,
-    Subtype.nms_adpcm_32: SdType.int32,
     Subtype.pcm_16: SdType.int16,
     Subtype.pcm_24: SdType.int32,
     Subtype.pcm_32: SdType.int32,

{recs-0.3.1 → recs-0.10.0}/recs/base/types.py

@@ -3,7 +3,6 @@ from enum import auto
 
 from strenum import StrEnum
 
-DeviceDict = dict[str, float | int | str]
 Stop = t.Callable[[], None]
 
 
@@ -23,27 +22,14 @@ SDTYPE = SdType.float32
 
 
 class Format(StrEnum):
-    aiff = auto()
-    au = auto()
-    avr = auto()
-    caf = auto()
     flac = auto()
-    ircam = auto()
-    mat4 = auto()
-    mat5 = auto()
     mp3 = auto()
-    mpc2k = auto()
-    nist = auto()
     ogg = auto()
-    paf = auto()
-    pvf = auto()
     raw = auto()
     rf64 = auto()
-    sd2 = auto()
-    voc = auto()
-    w64 = auto()
     wav = auto()
-    wavex = auto()
+
+    _default = wav
 
 
 class Subtype(StrEnum):
@@ -51,33 +37,15 @@ class Subtype(StrEnum):
     alac_20 = auto()
     alac_24 = auto()
     alac_32 = auto()
-    alaw = auto()
     double = auto()
-    dpcm_16 = auto()
-    dpcm_8 = auto()
-    dwvw_12 = auto()
-    dwvw_16 = auto()
-    dwvw_24 = auto()
-    dwvw_n = auto()
     float = auto()
-    g721_32 = auto()
-    g723_24 = auto()
-    g723_40 = auto()
-    gsm610 = auto()
-    ima_adpcm = auto()
     mpeg_layer_i = auto()
     mpeg_layer_ii = auto()
     mpeg_layer_iii = auto()
-    ms_adpcm = auto()
-    nms_adpcm_16 = auto()
-    nms_adpcm_24 = auto()
-    nms_adpcm_32 = auto()
     opus = auto()
     pcm_16 = auto()
     pcm_24 = auto()
     pcm_32 = auto()
     pcm_s8 = auto()
     pcm_u8 = auto()
-    ulaw = auto()
     vorbis = auto()
-    vox_adpcm = auto()

recs-0.10.0/recs/cfg/__init__.py

@@ -0,0 +1,8 @@
+from .aliases import Aliases
+from .cfg import Cfg
+from .device import InputDevice
+from .file_source import FileSource
+from .source import Source
+from .track import Track
+
+__all__ = 'Aliases', 'Cfg', 'FileSource', 'InputDevice', 'Source', 'Track'