recs 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

recs/__main__.py

@@ -1,6 +1,29 @@
-if __name__ == '__main__':
-    import sys
+import sys
+
+import click
+
+from recs.base import RecsError
+from recs.cfg import app, cli
+
+assert cli
+
+
+def run() -> int:
+    try:
+        app.app(prog_name='recs', standalone_mode=False)
+        return 0
 
-    from recs.cfg import cli
+    except RecsError as e:
+        print('ERROR:', *e.args, file=sys.stderr)
 
-    sys.exit(cli.run())
+    except click.ClickException as e:
+        print(f'{e.__class__.__name__}: {e.message}', file=sys.stderr)
+
+    except click.Abort:
+        print('Interrupted', file=sys.stderr)
+
+    return -1
+
+
+if __name__ == '__main__':
+    sys.exit(run())

recs/audio/block.py

@@ -37,7 +37,7 @@ class Block:
 
     @cached_property
     def volume(self) -> float:
-        return sum(self.amplitude) / len(self.amplitude) / self.scale
+        return sum(self.amplitude) / len(self.amplitude)
 
     @cached_property
     def channel_count(self) -> int:
@@ -45,7 +45,7 @@ class Block:
 
     @cached_property
     def amplitude(self) -> np.ndarray:
-        return (self.max - self.min) / 2
+        return (self.max - self.min) / (2 * self.scale)
 
     @cached_property
     def max(self) -> np.ndarray:
@@ -99,6 +99,3 @@ class Blocks:
 
     def __getitem__(self, i: int) -> Block:
         return self.blocks[i]
-
-    def __len__(self) -> int:
-        return len(self.blocks)

recs/audio/channel_writer.py

@@ -1,17 +1,18 @@
+import contextlib
 import typing as t
 from datetime import datetime
 from pathlib import Path
 from threading import Lock
 
+from overrides import override
 from soundfile import SoundFile
 from threa import Runnable
 
-from recs.base import times
+from recs.base.state import ChannelState
 from recs.base.types import SDTYPE, Active, Format, SdType
-from recs.cfg import Track
-from recs.misc import file_list
+from recs.cfg import Cfg, Track, device, time_settings
+from recs.misc import counter, file_list
 
-from ..cfg.cfg import Cfg
 from .block import Block, Blocks
 from .file_opener import FileOpener
 from .header_size import header_size
@@ -27,7 +28,6 @@ FORMAT_TO_SIZE_LIMIT = {
 ITEMSIZE = {
     SdType.float32: 4,
     SdType.int16: 2,
-    SdType.int24: 3,
     SdType.int32: 4,
 }
 
@@ -35,20 +35,15 @@ BLOCK_FUZZ = 2
 
 
 class ChannelWriter(Runnable):
-    blocks_seen: int = 0
-    blocks_written: int = 0
     bytes_in_this_file: int = 0
 
     frames_in_this_file: int = 0
-    frames_seen: int = 0
-    frame_size: int = 0
-    frames_written: int = 0
+    frames_written: int = 0  # Used elsewhere
 
     largest_file_size: int = 0
     longest_file_frames: int = 0
 
     timestamp: float = 0
-    tracknumber: int = 0
 
     _sf: SoundFile | None = None
 
@@ -56,10 +51,12 @@ class ChannelWriter(Runnable):
     def active(self) -> Active:
         return Active.active if self._sf else Active.inactive
 
-    def __init__(self, cfg: Cfg, times: times.TimeSettings[int], track: Track) -> None:
+    def __init__(
+        self, cfg: Cfg, times: time_settings.TimeSettings[int], track: Track
+    ) -> None:
         super().__init__()
 
-        self.dry_run = cfg.dry_run
+        self.do_not_record = cfg.dry_run or cfg.calibrate
         self.format = cfg.format
         self.metadata = cfg.metadata
         self.times = times
@@ -72,51 +69,94 @@ class ChannelWriter(Runnable):
         self.frame_size = ITEMSIZE[cfg.sdtype or SDTYPE] * len(track.channels)
         self.longest_file_frames = times.longest_file_time
         self.opener = FileOpener(cfg, track)
+        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 update(self, update: device.Update) -> ChannelState:
+        block = Block(update.array[:, self.track.slice])
+        with self._lock:
+            return self._receive_block(block, update.timestamp)
+
+    @override
     def stop(self) -> None:
         with self._lock:
-            self.running.clear()
+            self.running = False
             self._write_and_close()
-            self.stopped.set()
+            self.stopped = True
 
-    def write(self, block: Block, timestamp: float) -> None:
-        self.frames_seen += len(block)
-        self.blocks_seen += 1
+    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):
+                sf.close()
+            with contextlib.suppress(Exception):
+                Path(sf.name).unlink()
 
-        if not self.dry_run and (self.running or self._sf):
-            dt = self.timestamp - timestamp
-            self.timestamp = timestamp
+    def _open(self, offset: int) -> SoundFile:
+        timestamp = self.timestamp - offset / self.track.device.samplerate
+        ts = datetime.fromtimestamp(timestamp)
 
-            with self._lock:
-                self._write(block, dt)
+        index = 1 + len(self.files_written)
 
-    def _write(self, block: Block, dt: float):
-        expected_dt = len(block) / self.track.device.samplerate
+        metadata = {'date': ts.isoformat(), 'software': URL, 'tracknumber': str(index)}
+        metadata |= self.metadata
 
-        if dt > expected_dt * BLOCK_FUZZ:
-            # We were asleep, or otherwise lost time.
-            self._write_and_close()
+        self.bytes_in_this_file = header_size(metadata, self.format)
+        self.frames_in_this_file = 0
 
-        self._blocks.append(block)
+        sf = self.opener.create(metadata, timestamp, index)
+        self.files_written.append(Path(sf.name))
+        return sf
 
-        if block.volume >= self.times.noise_floor_amplitude:
-            if not self._sf:
-                # Record a little quiet before the first block
-                length = self.times.quiet_before_start + len(self._blocks[-1])
-                self._blocks.clip(length, from_start=True)
+    def _receive_block(self, block: Block, timestamp: float) -> ChannelState:
+        saved_state = self._state(
+            max_amp=max(block.max) / block.scale,
+            min_amp=min(block.min) / block.scale,
+        )
 
-            self._write_blocks(self._blocks)
-            self._blocks.clear()
+        dt = self.timestamp - timestamp
+        self.timestamp = timestamp
+        self._volume(block)
 
-        if not self.running or self._blocks.duration > self.times.stop_after_quiet:
-            self._write_and_close()
+        if not self.do_not_record and (self._sf or not self.stopped):
+            expected_dt = len(block) / self.track.device.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
+                    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) -> 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,
+            timestamp=self.timestamp,
+            volume=tuple(self._volume.mean()),
+            **kwargs,
+        )
 
     def _write_and_close(self) -> None:
-        # Record a little quiet after the last block
+        # Record some quiet after the last block
         removed = self._blocks.clip(self.times.quiet_after_end, from_start=False)
 
         if self._sf and removed:
@@ -124,15 +164,13 @@ class ChannelWriter(Runnable):
 
         self._close()
 
-    def _close(self) -> None:
-        if self._sf:
-            self._sf.close()
-            if self._sf.frames <= self.times.shortest_file_time:
-                if (p := Path(self._sf.name)).exists():
-                    p.unlink()
-            self._sf = None
-
-    def _write_blocks(self, blocks: t.Iterable[Block]) -> None:
+    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] = []
@@ -140,39 +178,17 @@ class ChannelWriter(Runnable):
             if self.longest_file_frames:
                 remains.append(self.longest_file_frames - self.frames_in_this_file)
 
-            if self.largest_file_size and self._sf:
+            if self._sf and self.largest_file_size:
                 file_bytes = self.largest_file_size - self.bytes_in_this_file
                 remains.append(file_bytes // self.frame_size)
 
-            if remains and (r := min(remains)) <= len(b):
-                self._write_one(b[:r])
+            if remains and min(remains) <= len(b):
                 self._close()
-                b = b[r:]
-
-            if b:
-                self._write_one(b)
-
-    def _write_one(self, b: Block) -> None:
-        if not self._sf:
-            self.tracknumber += 1
-            t = str(self.tracknumber)
-            # TODO: the timestamp will be a bit late for this block
-            # because self.timestamp is the time of the last block
-            # in the list!
-            ts = datetime.fromtimestamp(self.timestamp)
-            metadata = dict(date=ts.isoformat(), software=URL, tracknumber=t)
-            metadata |= self.metadata
-
-            self._sf = self.opener.create(metadata, timestamp=self.timestamp)
-            self.bytes_in_this_file = header_size(metadata, self.format)
-
-            self.files_written.append(Path(self._sf.name))
-            self.frames_in_this_file = 0
-
-        self._sf.write(b.block)
 
-        self.blocks_written += 1
-        self.frames_in_this_file += len(b)
-        self.frames_written += len(b)
+            self._sf = self._sf or self._open(offset)
+            self._sf.write(b.block)
+            offset += len(b)
 
-        self.bytes_in_this_file += len(b) * self.frame_size
+            self.frames_in_this_file += len(b)
+            self.frames_written += len(b)
+            self.bytes_in_this_file += len(b) * self.frame_size

recs/audio/file_opener.py

@@ -1,9 +1,10 @@
+import itertools
 from pathlib import Path
 
 import soundfile as sf
 
 from recs.cfg import Cfg, Track
-from recs.misc.recording_path import recording_path
+from recs.cfg.metadata import ALLOWS_METADATA
 
 
 class FileOpener:
@@ -27,23 +28,21 @@ class FileOpener:
             subtype=self.cfg.subtype,
         )
 
-        for k, v in metadata.items():
-            setattr(fp, k, v)
+        if self.cfg.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) -> sf.SoundFile:
-        index = 0
-        suffix = ''
-        path, name = recording_path(
-            self.track, self.cfg.aliases, self.cfg.subdirectory, timestamp
-        )
+    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)
 
-        while True:
-            p = self.cfg.path / path / (name + suffix)
-            p.parent.mkdir(exist_ok=True, parents=True)
+        for i in itertools.count():
+            f = p.parent / (p.name + bool(i) * f'_{i}')
             try:
-                return self.open(p, metadata)
+                return self.open(f, metadata)
             except FileExistsError:
-                index += 1
-                suffix = f'_{index}'
+                pass

recs/base/_query_device.py

@@ -0,0 +1,21 @@
+"""
+Print the current devices as JSON without loading any other part of recs.
+
+Called repeatedly as a subprocess to detect devices going off- and online.
+"""
+
+import json
+import typing as t
+
+
+def query_devices() -> list[dict[str, t.Any]]:
+    try:
+        import sounddevice
+
+        return sounddevice.query_devices()
+    except Exception:
+        return []
+
+
+if __name__ == '__main__':
+    print(json.dumps(query_devices(), indent=4))

recs/base/cfg_raw.py

@@ -11,15 +11,15 @@ class CfgRaw:
     #
     # Directory settings
     #
-    path: Path = Path()
-    subdirectory: t.Sequence[str] = ()
+    path: str = ''
     #
     # General purpose settings
     #
+    calibrate: bool = False
     dry_run: bool = False
+    verbose: bool = False
     info: bool = False
     list_types: bool = False
-    verbose: bool = False
     #
     # Aliases for input devices or channels
     #
@@ -40,19 +40,21 @@ class CfgRaw:
     #
     # Console and UI settings
     #
+    clear: bool = False
     silent: bool = False
-    retain: bool = True
-    ui_refresh_rate: float = 23
-    sleep_time: float = 0.013
+    sleep_time_device: float = 0.1
+    ui_refresh_rate: float = 23.0
     #
     # Settings relating to times
     #
     infinite_length: bool = False
-    longest_file_time: str = '0'  # In HH:MM:SS.SSSS
-    moving_average_time: float = 1
-    noise_floor: float = 70
-    shortest_file_time: str = '1'  # In HH:MM:SS.SSSS
-    quiet_after_end: float = 2
-    quiet_before_start: float = 1
-    stop_after_quiet: float = 20
-    total_run_time: float = 0
+    longest_file_time: float = 0.0
+    moving_average_time: float = 1.0
+    noise_floor: float = 70.0
+    shortest_file_time: float = 1.0
+    quiet_after_end: float = 2.0
+    quiet_before_start: float = 1.0
+    stop_after_quiet: float = 20.0
+    total_run_time: float = 0.0
+
+    asdict = dc.asdict

recs/base/prefix_dict.py

@@ -8,20 +8,19 @@ class PrefixDict(dict[str, T]):
         try:
             return super().__getitem__(key)
         except KeyError:
-            if not key:
-                raise
-            key = key.strip().lower()
+            pass
+
+        error = 'unknown'
+        if key := key.strip().lower():
             try:
                 return super().__getitem__(key)
             except KeyError:
                 pass
 
-            if 1 == len(m := [v for k, v in self.items() if k.lower().startswith(key)]):
-                return m[0]
-            raise
+            matches = [v for k, v in self.items() if k.lower().startswith(key)]
+            if len(matches) == 1:
+                return matches[0]
+            if matches:
+                error = 'ambiguous'
 
-    def get_value(self, key: str, default: T | None = None) -> T | None:
-        try:
-            return self[key]
-        except KeyError:
-            return default
+        raise KeyError(key, error)

recs/base/state.py

@@ -0,0 +1,73 @@
+import dataclasses as dc
+import time
+
+from recs.cfg.time_settings import amplitude_to_db
+
+INF = float('inf')
+
+
+@dc.dataclass(slots=True)
+class ChannelState:
+    """Represents the state of a single recording channel"""
+
+    condition: str = 'running'
+
+    file_count: int = 0
+    file_size: int = 0
+
+    is_active: bool = False
+
+    max_amp: float = -INF
+    min_amp: float = INF
+
+    recorded_time: float = 0
+    timestamp: float = dc.field(default_factory=time.time)
+    volume: tuple[float, ...] = ()
+
+    replace = dc.replace
+
+    @property
+    def amp(self) -> float:
+        if self.max_amp == -INF or self.min_amp == INF:
+            return 0
+        return (self.max_amp - self.min_amp) / 2
+
+    @property
+    def db_range(self) -> float:
+        return amplitude_to_db(self.amp)
+
+    def __iadd__(self, m: 'ChannelState') -> 'ChannelState':
+        self.file_count += m.file_count
+        self.file_size += m.file_size
+        self.recorded_time += m.recorded_time
+
+        # We copy these three when using +=, but not -=!
+        self.condition = m.condition
+        self.is_active = m.is_active
+        self.timestamp = m.timestamp
+        self.volume = m.volume
+
+        self.max_amp = max(self.max_amp, m.max_amp)
+        self.min_amp = min(self.min_amp, m.min_amp)
+
+        return self
+
+    def __isub__(self, m: 'ChannelState') -> 'ChannelState':
+        self.file_count -= m.file_count
+        self.file_size -= m.file_size
+        self.recorded_time -= m.recorded_time
+
+        self.max_amp = max(self.max_amp, m.max_amp)
+        self.min_amp = min(self.min_amp, m.min_amp)
+
+        return self
+
+    def __add__(self, m: 'ChannelState') -> 'ChannelState':
+        x = self.replace()
+        x += m
+        return x
+
+    def __sub__(self, m: 'ChannelState') -> 'ChannelState':
+        x = self.replace()
+        x -= m
+        return x

recs/base/times.py

@@ -1,66 +1,7 @@
-import dataclasses as dc
-import math
-import time as _time
-import typing as t
-from functools import cached_property
+import time
 
-T = t.TypeVar('T', float, int)
-NO_SCALE = ('noise_floor',)
-
-sleep = _time.sleep
-time = _time.time
-
-
-def db_to_amplitude(db: float) -> float:
-    return 10 ** (-db / 20)
-
-
-def amplitude_to_db(amp: float) -> float:
-    return -20 * math.log10(amp)
-
-
-@dc.dataclass(frozen=True)
-class TimeSettings(t.Generic[T]):
-    """Amounts of time are specified as seconds in the input but converted
-    to samples when we find out the sample rate
-    """
-
-    #: Longest amount of time per file: 0 means infinite
-    longest_file_time: T = t.cast(T, 0)
-
-    #: Shortest amount of time per file
-    shortest_file_time: T = t.cast(T, 0)
-
-    #: Amount of quiet at the start
-    quiet_before_start: T = t.cast(T, 0)
-
-    #: Amount of quiet at the end
-    quiet_after_end: T = t.cast(T, 0)
-
-    #: Amount of quiet before stopping a recording
-    stop_after_quiet: T = t.cast(T, 0)
-
-    # Time for moving averages for the meters
-    moving_average_time: T = t.cast(T, 0)
-
-    #: The noise floor in decibels
-    noise_floor: float = 70
-
-    #: Amount of total time to run.  0 or less means "run forever"
-    total_run_time: T = t.cast(T, 0)
-
-    @cached_property
-    def noise_floor_amplitude(self) -> float:
-        return db_to_amplitude(self.noise_floor)
-
-    def __post_init__(self):
-        if negative_fields := [k for k, v in dc.asdict(self).items() if v < 0]:
-            raise ValueError(f'TimeSettings cannot be negative: {negative_fields=}')
-
-    def scale(self, samplerate: float | int) -> 'TimeSettings[int]':
-        it = dc.asdict(self).items()
-        d = {k: v if k in NO_SCALE else round(samplerate * v) for k, v in it}
-        return TimeSettings[int](**d)
+sleep = time.sleep
+timestamp = time.time
 
 
 def to_time(t: str) -> float:

recs/base/type_conversions.py

@@ -2,26 +2,27 @@ from .prefix_dict import PrefixDict
 from .types import Format, SdType, Subtype
 
 FORMATS = PrefixDict[Format]({str(s): s for s in Format})
+SDTYPES = PrefixDict[SdType]({str(s): s for s in SdType})
 SUBTYPES = PrefixDict[Subtype]({str(s): s for s in Subtype})
 
 SUBTYPE_TO_SDTYPE = {
     Subtype.alac_16: SdType.int16,
     Subtype.alac_20: SdType.int32,
-    Subtype.alac_24: SdType.int24,
+    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.int24,
+    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.int24,
+    Subtype.nms_adpcm_24: SdType.int32,
     Subtype.nms_adpcm_32: SdType.int32,
     Subtype.pcm_16: SdType.int16,
-    Subtype.pcm_24: SdType.int24,
+    Subtype.pcm_24: SdType.int32,
     Subtype.pcm_32: SdType.int32,
     Subtype.pcm_s8: SdType.int16,
     Subtype.pcm_u8: SdType.int16,
@@ -29,7 +30,6 @@ SUBTYPE_TO_SDTYPE = {
 
 SDTYPE_TO_SUBTYPE = {
     SdType.int16: Subtype.pcm_16,
-    SdType.int24: Subtype.pcm_24,
     SdType.int32: Subtype.pcm_32,
     SdType.float32: Subtype.float,
 }

recs/base/types.py

@@ -1,8 +1,10 @@
+import typing as t
 from enum import auto
 
 from strenum import StrEnum
 
 DeviceDict = dict[str, float | int | str]
+Stop = t.Callable[[], None]
 
 
 class Active(StrEnum):
@@ -14,7 +16,6 @@ class Active(StrEnum):
 class SdType(StrEnum):
     float32 = auto()
     int16 = auto()
-    int24 = auto()
     int32 = auto()
 
 
@@ -80,9 +81,3 @@ class Subtype(StrEnum):
     ulaw = auto()
     vorbis = auto()
     vox_adpcm = auto()
-
-
-class Subdirectory(StrEnum):
-    channel = auto()
-    device = auto()
-    time = auto()