recs 0.3.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

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/audio/channel_writer.py

@@ -1,16 +1,19 @@
 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, device, time_settings
+from recs.cfg import Cfg, Track, time_settings
 from recs.misc import counter, file_list
 
 from .block import Block, Blocks
@@ -19,11 +22,8 @@ from .header_size import header_size
 
 URL = 'https://github.com/rec/recs'
 
-BUFFER = 128
-FORMAT_TO_SIZE_LIMIT = {
-    Format.aiff: 0x8000_0000,
-    Format.wav: 0x1_0000_0000,
-}
+BUFFER = 0x80
+MAX_WAV_SIZE = 0x1_0000_0000 - BUFFER
 
 ITEMSIZE = {
     SdType.float32: 4,
@@ -35,9 +35,9 @@ BLOCK_FUZZ = 2
 
 
 class ChannelWriter(Runnable):
-    bytes_in_this_file: int = 0
+    bytes_in_file: int = 0
 
-    frames_in_this_file: int = 0
+    frames_in_file: int = 0
     frames_written: int = 0  # Used elsewhere
 
     largest_file_size: int = 0
@@ -45,19 +45,19 @@ class ChannelWriter(Runnable):
 
     timestamp: float = 0
 
-    _sf: SoundFile | None = None
+    _sfs: t.Sequence[SoundFile] = ()
 
     @property
     def active(self) -> Active:
-        return Active.active if self._sf else Active.inactive
+        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.format = cfg.format
         self.metadata = cfg.metadata
         self.times = times
         self.track = track
@@ -65,20 +65,58 @@ class ChannelWriter(Runnable):
         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[cfg.sdtype or SDTYPE] * len(track.channels)
+        self.frame_size = ITEMSIZE[sdtype] * len(track.channels)
         self.longest_file_frames = times.longest_file_time
-        self.opener = FileOpener(cfg, track)
+
+        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)
 
-        if not cfg.infinite_length:
-            largest = FORMAT_TO_SIZE_LIMIT.get(cfg.format, 0)
-            self.largest_file_size = max(largest - BUFFER, 0)
+        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 update(self, update: device.Update) -> ChannelState:
-        block = Block(update.array[:, self.track.slice])
+    def receive_update(
+        self, block: Block, timestamp: float, should_record: bool = False
+    ) -> ChannelState:
         with self._lock:
-            return self._receive_block(block, update.timestamp)
+            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:
@@ -88,32 +126,37 @@ class ChannelWriter(Runnable):
             self.stopped = True
 
     def _close(self) -> None:
-        sf, self._sf = self._sf, None
-        if sf and sf.frames and sf.frames >= self.times.shortest_file_time:
-            sf.close()
-        elif sf:
-            with contextlib.suppress(Exception):
+        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()
-            with contextlib.suppress(Exception):
-                Path(sf.name).unlink()
-
-    def _open(self, offset: int) -> SoundFile:
-        timestamp = self.timestamp - offset / self.track.device.samplerate
-        ts = datetime.fromtimestamp(timestamp)
-
+            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': ts.isoformat(), 'software': URL, 'tracknumber': str(index)}
+        metadata = {'date': date, 'software': URL, 'tracknumber': str(index)}
         metadata |= self.metadata
 
-        self.bytes_in_this_file = header_size(metadata, self.format)
-        self.frames_in_this_file = 0
+        self.bytes_in_file = max(header_size(metadata, f) for f in self.cfg.formats)
+        self.frames_in_file = 0
 
-        sf = self.opener.create(metadata, timestamp, index)
-        self.files_written.append(Path(sf.name))
-        return sf
+        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) -> ChannelState:
+    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,
@@ -123,16 +166,16 @@ class ChannelWriter(Runnable):
         self.timestamp = timestamp
         self._volume(block)
 
-        if not self.do_not_record and (self._sf or not self.stopped):
-            expected_dt = len(block) / self.track.device.samplerate
+        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 block.volume >= self.times.noise_floor_amplitude:
-                if not self._sf:  # Record some quiet before the first 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)
 
@@ -144,12 +187,12 @@ class ChannelWriter(Runnable):
 
         return self._state() - saved_state
 
-    def _state(self, **kwargs) -> ChannelState:
+    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._sf),
-            recorded_time=self.frames_written / self.track.device.samplerate,
+            is_active=bool(self._sfs),
+            recorded_time=self.frames_written / self.track.source.samplerate,
             timestamp=self.timestamp,
             volume=tuple(self._volume.mean()),
             **kwargs,
@@ -159,7 +202,7 @@ class ChannelWriter(Runnable):
         # Record some quiet after the last block
         removed = self._blocks.clip(self.times.quiet_after_end, from_start=False)
 
-        if self._sf and removed:
+        if self._sfs and removed:
             self._write_blocks(reversed(removed))
 
         self._close()
@@ -176,19 +219,20 @@ class ChannelWriter(Runnable):
             remains: list[int] = []
 
             if self.longest_file_frames:
-                remains.append(self.longest_file_frames - self.frames_in_this_file)
+                remains.append(self.longest_file_frames - self.frames_in_file)
 
-            if self._sf and self.largest_file_size:
-                file_bytes = self.largest_file_size - self.bytes_in_this_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._sf = self._sf or self._open(offset)
-            self._sf.write(b.block)
+            self._sfs = self._sfs or self._open(offset)
+            for sf in self._sfs:
+                sf.write(b.block)
             offset += len(b)
 
-            self.frames_in_this_file += len(b)
+            self.frames_in_file += len(b)
             self.frames_written += len(b)
-            self.bytes_in_this_file += len(b) * self.frame_size
+            self.bytes_in_file += len(b) * self.frame_size

recs/audio/file_opener.py

@@ -1,48 +1,50 @@
+import dataclasses as dc
 import itertools
+import typing as t
 from pathlib import Path
 
-import soundfile as sf
+import soundfile
 
-from recs.cfg import Cfg, Track
+from recs.base.types import Format, Subtype
 from recs.cfg.metadata import ALLOWS_METADATA
 
 
+@dc.dataclass
 class FileOpener:
-    def __init__(self, cfg: Cfg, track: Track) -> None:
-        self.cfg = cfg
-        self.track = track
+    format: Format
+    channels: int = 1
+    samplerate: int = 48_000
+    subtype: Subtype | None = None
 
     def open(
-        self, path: Path | str, metadata: dict[str, str], overwrite: bool = False
-    ) -> sf.SoundFile:
-        path = Path(path).with_suffix('.' + self.cfg.format)
+        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 = sf.SoundFile(
-            channels=len(self.track.channels),
+        fp = soundfile.SoundFile(
+            channels=self.channels,
             file=path,
-            format=self.cfg.format,
+            format=self.format,
             mode='w',
-            samplerate=self.track.device.samplerate,
-            subtype=self.cfg.subtype,
+            samplerate=self.samplerate,
+            subtype=self.subtype,
         )
 
-        if self.cfg.format in ALLOWS_METADATA:
+        if self.format in ALLOWS_METADATA:
             for k, v in metadata.items():
                 setattr(fp, k, v)
 
         return fp
 
-    def create(
-        self, metadata: dict[str, str], timestamp: float, index: int
-    ) -> sf.SoundFile:
-        p = Path(self.cfg.path.evaluate(self.track, self.cfg.aliases, timestamp, index))
-        p.parent.mkdir(exist_ok=True, parents=True)
+    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 = p.parent / (p.name + bool(i) * f'_{i}')
+            f = path.parent / (path.name + bool(i) * f'_{i}')
             try:
                 return self.open(f, metadata)
             except FileExistsError:
                 pass
+        raise FileNotFoundError

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/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/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/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/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/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/cfg/__init__.py

@@ -1,15 +1,8 @@
 from .aliases import Aliases
 from .cfg import Cfg
-from .device import InputDevice, InputDevices, InputStream
-from .path_pattern import PathPattern
+from .device import InputDevice
+from .file_source import FileSource
+from .source import Source
 from .track import Track
 
-__all__ = (
-    'Aliases',
-    'Cfg',
-    'InputDevice',
-    'InputDevices',
-    'InputStream',
-    'PathPattern',
-    'Track',
-)
+__all__ = 'Aliases', 'Cfg', 'FileSource', 'InputDevice', 'Source', 'Track'

recs/cfg/aliases.py

@@ -1,10 +1,10 @@
 import typing as t
 
+from recs.base import RecsError, prefix_dict
 from recs.base.prefix_dict import PrefixDict
-from recs.base import prefix_dict, RecsError
 
-
-from .device import InputDevice, InputDevices
+from .device import InputDevices
+from .source import Source
 from .track import Track
 
 CHANNEL_SPLITTER = '+'
@@ -15,11 +15,9 @@ class Aliases:
 
     def __init__(self, aliases: t.Sequence[str], devices: InputDevices) -> None:
         self.tracks = PrefixDict()
-
-        assert devices
         self.devices = devices
 
-        if not aliases:
+        if not (aliases and devices):
             self.inv = {}
             return
 
@@ -27,11 +25,11 @@ class Aliases:
             alias, sep, value = (n.strip() for n in name.partition('='))
             return alias, (value or alias)
 
-        names, values = zip(*(split(n) for n in aliases))
+        names, values = zip(*(split(n) for n in aliases), strict=False)
         if len(set(names)) < len(names):
             raise RecsError(f'Duplicate aliases: {aliases}')
 
-        self.tracks.update(sorted(zip(names, self.to_tracks(values))))
+        self.tracks.update(sorted(zip(names, self.to_tracks(values), strict=False)))
 
         inv: dict[Track, list[str]] = {}
         for k, v in self.tracks.items():
@@ -56,7 +54,7 @@ class Aliases:
         if not errors:
             return result
 
-        def err(k, v) -> str:
+        def err(k: str, v: list[str]) -> str:
             s = 's' * (len(v) != 1)
             return f'{k.capitalize()} device name{s}: {", ".join(v)}'
 
@@ -66,8 +64,8 @@ class Aliases:
 
         raise RecsError('\n'.join([*errs, devices]))
 
-    def display_name(self, x: InputDevice | Track, short: bool = True) -> str:
-        if isinstance(x, InputDevice):
+    def display_name(self, x: Source | Track, short: bool = True) -> str:
+        if isinstance(x, Source):
             return self.inv.get(Track(x), x.name)
 
         default = x.name if short else str(x)
@@ -83,10 +81,8 @@ class Aliases:
         try:
             track = self.tracks[name]
         except KeyError:
-            device = self.devices[name]
-        else:
-            if track.channels:
-                raise KeyError(track_name, 'impossible')
-            device = track.device
+            return Track(self.devices[name], channels)
 
-        return Track(device, channels)
+        if track.channels:
+            raise KeyError(track_name, 'impossible')
+        return Track(track.source, channels)