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

recs/cfg/run_cli.py

@@ -0,0 +1,43 @@
+import json
+
+import soundfile as sf
+
+from recs.base.types import Format, SdType
+from recs.cfg import device
+from recs.ui.recorder import Recorder
+
+from . import Cfg
+
+
+def run_cli(cfg: Cfg) -> None:
+    if cfg.info:
+        return _info()
+
+    if cfg.list_types:
+        return _list_types()
+
+    rec = Recorder(cfg)
+    try:
+        rec.run_recorder()
+    finally:
+        if cfg.calibrate:
+            states = rec.state.state.items()
+            d = {j: {k: v.db_range for k, v in u.items()} for j, u in states}
+            d2 = {'(all)': rec.state.total.db_range}
+            print(json.dumps(d | d2, indent=2))
+
+
+def _list_types() -> None:
+    avail = sf.available_formats()
+    fmts = [f.upper() for f in Format]
+    formats = {f: [avail[f], sf.available_subtypes(f)] for f in fmts}
+    sdtypes = [str(s) for s in SdType]
+    d = {'formats': formats, 'sdtypes': sdtypes}
+
+    print(json.dumps(d, indent=4))
+
+
+def _info() -> None:
+    info = device.query_devices()
+    info2 = [i for i in info if i['max_input_channels']]
+    print(json.dumps(info2, indent=4))

recs/cfg/time_settings.py

@@ -0,0 +1,61 @@
+import dataclasses as dc
+import math
+import typing as t
+from functools import cached_property
+
+T = t.TypeVar('T', float, int)
+NO_SCALE = ('noise_floor',)
+
+
+def db_to_amplitude(db: float) -> float:
+    return 10 ** (-db / 20)
+
+
+def amplitude_to_db(amp: float) -> float:
+    if amp > 0:
+        return -20 * math.log10(amp)
+    return float('inf')
+
+
+@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)

recs/cfg/track.py

@@ -1,6 +1,6 @@
 from recs.base import RecsError
-from recs.misc import hash_cmp
 
+from . import hash_cmp
 from .device import InputDevice
 
 __all__ = ('Track',)
@@ -21,15 +21,15 @@ class Track(hash_cmp.HashCmp):
         if self.channels:
             a, b = self.channels[0], self.channels[-1]
             self.slice = slice(a - 1, b)
-            self.channels_name = f'{a}' if a == b else f'{a}-{b}'
+            self.name = f'{a}' if a == b else f'{a}-{b}'
 
         else:
             self.slice = slice(0)
-            self.channels_name = ''
+            self.name = ''
 
     def __str__(self) -> str:
         if self.channels:
-            return f'{self.device.name} + {self.channels_name}'
+            return f'{self.device.name} + {self.name}'
         return self.device.name
 
     def __repr__(self) -> str:

recs/misc/contexts.py

@@ -0,0 +1,10 @@
+import typing as t
+from contextlib import ExitStack, contextmanager
+
+
+@contextmanager
+def contexts(*contexts: t.ContextManager) -> t.Generator:
+    with ExitStack() as stack:
+        for c in contexts:
+            stack.enter_context(c)
+        yield

recs/misc/counter.py

@@ -51,20 +51,21 @@ class Accumulator:
 
 
 class MovingBlock:
-    _deque: deque[Num] | None = None
+    _dq: deque[np.ndarray] | None = None
 
     def __init__(self, moving_average_time: int):
         self.moving_average_time = moving_average_time
 
     def __call__(self, b: Block) -> None:
-        if not self._deque:
+        if self._dq is None:
             maxlen = int(0.5 + self.moving_average_time / len(b))
-            self._deque = deque((), maxlen)
+            self._dq = deque((), maxlen)
 
-        self._deque.append(b.volume)
+        self._dq.append(b.amplitude)
 
-    def mean(self) -> Num:
-        if not self._deque:
-            return 0
+    def mean(self) -> np.ndarray:
+        if not self._dq:
+            return np.array([0])
 
-        return sum(self._deque) / len(self._deque)
+        it = (d for i, d in enumerate(self._dq) if i)
+        return sum(it, start=self._dq[0]) / len(self._dq)

recs/misc/legal_filename.py

@@ -1,6 +1,6 @@
 import string
 
-PUNCTUATION = ' ()+,-.=[]_'
+PUNCTUATION = ' ()+,-.=[]_/'
 CHARS = set(string.ascii_letters + string.digits + PUNCTUATION)
 
 

recs/misc/log.py

@@ -0,0 +1,43 @@
+import os
+import typing as t
+from functools import cache, wraps
+
+C = t.TypeVar('C', bound=t.Callable)
+
+DISABLE = False
+
+# Some sort of global state is needed here so that we can decorate
+# methods without having to have a Cfg around.
+VERBOSE = not False
+
+
+@cache
+def _logger():
+    return open(f'/tmp/log-{os.getpid()}.txt', 'w')
+
+
+def log(*a, **ka) -> None:
+    print(*a, **ka, file=_logger())
+
+
+def verbose(*a, **ka) -> None:
+    if VERBOSE:
+        log(*a, **ka)
+
+
+def logged(function: C) -> C:
+    if DISABLE:
+        return function
+
+    @wraps(function)
+    def wrapped(*args, **kwargs):
+        verbose(function, 'before')
+        try:
+            return function(*args, **kwargs)
+        except BaseException as e:
+            verbose(function, 'exception', type(e), *e.args)
+            raise
+        finally:
+            verbose(function, 'after')
+
+    return t.cast(C, wrapped)

recs/ui/__init__.py

@@ -1 +0,0 @@
-

recs/ui/device_process.py

@@ -0,0 +1,37 @@
+import multiprocessing as mp
+import typing as t
+from threading import Lock
+
+from overrides import override
+from threa import Wrapper
+
+from recs.cfg import Cfg, Track
+from recs.ui.device_recorder import DeviceRecorder
+
+
+class DeviceProcess(Wrapper):
+    status: str = 'ok'
+    sent: bool = False
+
+    def __init__(self, cfg: Cfg, tracks: t.Sequence[Track]) -> None:
+        self.connection, child = mp.Pipe()
+        self._lock = Lock()
+        kwargs = {'cfg': cfg.cfg, 'connection': child, 'tracks': tracks}
+        self.process = mp.Process(target=DeviceRecorder, kwargs=kwargs)
+        super().__init__(self.process)
+
+        self.device_name = tracks[0].device.name
+
+    def set_sent(self) -> bool:
+        with self._lock:
+            sent, self.sent = self.sent, True
+            return not sent
+
+    @override
+    def finish(self):
+        self.running = False
+        if self.set_sent():
+            self.connection.send(self.status)
+
+        self.process.join()
+        self.finished = True

recs/ui/device_recorder.py

@@ -1,99 +1,83 @@
-from __future__ import annotations
-
+import os
+import traceback
 import typing as t
-from functools import cached_property, partial
+from multiprocessing.connection import Connection
 
 import numpy as np
-from threa import Runnable
+from threa import Runnables, ThreadQueue, Wrapper
 
-from recs.base import times
-from recs.base.types import SDTYPE, Active, Format
+from recs.audio.channel_writer import ChannelWriter
+from recs.base import cfg_raw
+from recs.base.types import Format
 from recs.cfg import Cfg, Track
-from recs.misc.counter import Accumulator, Counter
+from recs.cfg.device import Update
 
+NEW_CODE_FLAG = 'RECS_NEW_CODE' in os.environ
+FINISH = 'finish'
 OFFLINE_TIME = 1
+POLL_TIMEOUT = 0.05
 
 
-class DeviceRecorder(Runnable):
-    def __init__(self, cfg: Cfg, tracks: t.Sequence[Track]) -> None:
-        from recs.ui.channel_recorder import ChannelRecorder
-
-        super().__init__()
-        self.cfg = cfg
+class DeviceRecorder(Runnables):
+    sample_count: int = 0
 
-        self.block_count = Counter()
-        self.block_size = Accumulator()
+    def __init__(
+        self,
+        cfg: cfg_raw.CfgRaw,
+        connection: Connection,
+        tracks: t.Sequence[Track],
+    ) -> None:
+        self.cfg = Cfg(**cfg.asdict())
+        self.connection = connection
 
         self.device = d = tracks[0].device
         self.name = self.cfg.aliases.display_name(d)
         self.times = self.cfg.times.scale(d.samplerate)
 
-        make = partial(ChannelRecorder, cfg=cfg, times=self.times)
-        self.channel_recorders = tuple(make(track=t) for t in tracks)
-        self.timestamp = times.time()
+        cw = (ChannelWriter(cfg=self.cfg, times=self.times, track=t) for t in tracks)
+        self.channel_writers = tuple(cw)
+        self.queue = ThreadQueue(self.device_callback, name=f'ThreadQueue-{d.name}')
+        self.input_stream = self.device.input_stream(
+            device_callback=self.queue.put,
+            sdtype=self.cfg.sdtype,
+            on_error=self.stop,
+        )
+        super().__init__(Wrapper(self.input_stream), self.queue, *self.channel_writers)
+        self.exit: dict[str, str | int] = {}
+
+        with self:
+            while not self.exit:
+                try:
+                    if connection.poll(POLL_TIMEOUT):
+                        if msg := connection.recv():
+                            self.queue.put({'reason': msg})
+                except KeyboardInterrupt:
+                    # We should never get here!
+                    print('Aborted', d.name)
+
+        self.connection.send({self.device.name: {'_exit': self.exit}})
+
+    def device_callback(self, update: Update | dict[str, t.Any]) -> None:
+        if self.exit:
+            return
+
+        if isinstance(update, dict):
+            self.exit = update
+        else:
+            try:
+                self._device_callback(update)
+            except Exception as e:
+                self.exit = {'reason': str(e), 'traceback': traceback.format_exc()}
+
+    def _device_callback(self, u: Update) -> None:
+        if self.cfg.format == Format.mp3 and u.array.dtype == np.float32:
+            # mp3 and float32 crashes every time on my machine
+            u = Update(u.array.astype(np.float64), u.timestamp)
 
-    def callback(self, array: np.ndarray, time: float) -> None:
-        self.timestamp = time
+        msgs = {c.track.name: c.update(u) for c in self.channel_writers}
 
-        if self.cfg.format == Format.mp3 and array.dtype == np.float32:
-            # mp3 and float32 crashes every time on my machine
-            array = array.astype(np.float64)
-
-        self.block_count()
-        self.block_size(array.shape[0])
-
-        if (t := self.times.total_run_time) and (extra := self.block_size.sum - t) >= 0:
-            self.stop()
-            if array.shape[0] <= extra:
-                return
-            array = array[slice(extra), :]
-
-        for c in self.channel_recorders:
-            c.callback(array, time)
-
-    def active(self) -> Active:
-        # TODO: this does work but we should probably bypass this
-        dt = times.time() - self.timestamp
-        return Active.offline if dt > OFFLINE_TIME else Active.active
-
-    def rows(self) -> t.Iterator[dict[str, t.Any]]:
-        active = self.active()
-        yield {'device': self.name, 'on': active}
-        for v in self.channel_recorders:
-            for r in v.rows():
-                if active == Active.offline:
-                    yield r | {'on': active}
-                else:
-                    yield r
-
-    def stop(self) -> None:
-        self.running.clear()
-        for c in self.channel_recorders:
-            c.stop()
-        self.stopped.set()
-
-    def __enter__(self):
-        if self.input_stream:
-            self.input_stream.__enter__()
-
-    def __exit__(self, *a) -> None:
-        if input_stream := self.__dict__.get('input_stream'):
-            return input_stream.__exit__(*a)
-
-    @property
-    def file_count(self) -> int:
-        return sum(c.file_count for c in self.channel_recorders)
-
-    @property
-    def file_size(self) -> int:
-        return sum(c.file_size for c in self.channel_recorders)
-
-    @property
-    def recorded_time(self) -> float:
-        return sum(c.recorded_time for c in self.channel_recorders)
-
-    @cached_property
-    def input_stream(self) -> t.Iterator[None] | None:
-        return self.device.input_stream(
-            callback=self.callback, dtype=self.cfg.sdtype or SDTYPE, stop=self.stop
-        )
+        self.connection.send({self.device.name: msgs})
+
+        self.sample_count += len(u.array)
+        if (t := self.times.total_run_time) and self.sample_count >= t:
+            self.exit = {'reason': 'total_run_time', 'samples': self.sample_count}

recs/ui/device_tracks.py

@@ -1,16 +1,24 @@
 import typing as t
 
+from recs.base import RecsError
 from recs.cfg import Cfg, InputDevice, Track
 
 DeviceTracks = dict[InputDevice, t.Sequence[Track]]
 
 
 def device_tracks(cfg: Cfg) -> DeviceTracks:
+    if not cfg.devices:
+        raise RecsError('No audio input devices were found')
+
     exc = cfg.aliases.to_tracks(cfg.exclude)
     inc = cfg.aliases.to_tracks(cfg.include)
 
     it = ((d, list(device_track(d, exc, inc))) for d in cfg.devices.values())
-    return {d: v for d, v in it if v}
+    ts: DeviceTracks = {d: v for d, v in it if v}
+    if ts:
+        return ts
+
+    raise RecsError('No channels selected')
 
 
 def device_track(

recs/ui/full_state.py

@@ -0,0 +1,50 @@
+import typing as t
+
+from recs.base import state, times
+from recs.base.types import Active
+from recs.cfg import InputDevice, Track
+
+
+class FullState:
+    def __init__(self, tracks: dict[InputDevice, t.Sequence[Track]]) -> None:
+        def device_state(t) -> dict[str, state.ChannelState]:
+            return {i.name: state.ChannelState() for i in t}
+
+        self.state = {k.name: device_state(v) for k, v in tracks.items()}
+        self.total = state.ChannelState()
+        self.start_time = times.timestamp()
+
+    @property
+    def elapsed_time(self) -> float:
+        return times.timestamp() - self.start_time
+
+    def update(self, state: dict[str, dict[str, state.ChannelState]]) -> None:
+        for device_name, device_state in state.items():
+            for channel_name, channel_state in device_state.items():
+                self.state[device_name][channel_name] += channel_state
+                self.total += channel_state
+                if '-' in channel_name:
+                    # This is a stereo channel, so count it again
+                    self.total.recorded_time += channel_state.recorded_time
+
+    def rows(self, devices: t.Sequence[str]) -> t.Iterator[dict[str, t.Any]]:
+        yield {
+            'time': self.elapsed_time,
+            'recorded': self.total.recorded_time,
+            'file_size': self.total.file_size,
+            'file_count': self.total.file_count,
+        }
+
+        for device_name, device_state in self.state.items():
+            active = Active.active if device_name in devices else Active.offline
+            yield {'device': device_name, 'on': active}  # TODO: use alias here
+
+            for c, s in device_state.items():
+                yield {
+                    'channel': c,  # TODO: use alias here
+                    'on': Active.active if s.is_active else Active.inactive,
+                    'recorded': s.recorded_time,
+                    'file_size': s.file_size,
+                    'file_count': s.file_count,
+                    'volume': len(s.volume) and sum(s.volume) / len(s.volume),
+                }

recs/ui/live.py

@@ -1,4 +1,3 @@
-import dataclasses as dc
 import typing as t
 from functools import cached_property
 
@@ -6,6 +5,7 @@ from humanfriendly import format_size
 from rich import live
 from rich.console import Console
 from rich.table import Table
+from threa import Runnable
 
 from recs.base import times
 from recs.base.types import Active
@@ -18,19 +18,17 @@ RowsFunction = t.Callable[[], t.Iterator[dict[str, t.Any]]]
 CONSOLE = Console(color_system='truecolor')
 
 
-@dc.dataclass
-class Live:
-    rows: RowsFunction
-    cfg: Cfg
-
+class Live(Runnable):
     _last_update_time: float = 0
 
+    def __init__(self, rows: RowsFunction, cfg: Cfg) -> None:
+        self.rows = rows
+        self.cfg = cfg
+        super().__init__()
+
     def update(self) -> None:
         if not self.cfg.silent:
-            t = times.time()
-            if (t - self._last_update_time) >= 1 / self.cfg.ui_refresh_rate:
-                self._last_update_time = t
-                self.live.update(self.table())
+            self.live.update(self.table())
 
     @cached_property
     def live(self) -> live.Live:
@@ -38,19 +36,21 @@ class Live:
             self.table(),
             console=CONSOLE,
             refresh_per_second=self.cfg.ui_refresh_rate,
-            transient=not self.cfg.retain,
+            transient=self.cfg.clear,
         )
 
     def table(self) -> Table:
         return TABLE_FORMATTER(self.rows())
 
-    def __enter__(self) -> None:
+    def start(self) -> None:
+        super().start()
         if not self.cfg.silent:
-            self.live.__enter__()
+            self.live.start(refresh=True)
 
-    def __exit__(self, *a) -> None:
+    def stop(self) -> None:
         if not self.cfg.silent:
-            self.live.__exit__(*a)
+            self.live.stop()
+        super().stop()
 
 
 def _rgb(r=0, g=0, b=0) -> str:
@@ -94,7 +94,19 @@ def _time_to_str(x) -> str:
 
 
 def _naturalsize(x: int) -> str:
-    return f'{format_size(x):>9}' if x else ''
+    if not x:
+        return ''
+
+    fs = format_size(x)
+
+    # Fix #97
+    value, _, unit = fs.partition(' ')
+    if unit != 'bytes':
+        integer, _, decimal = value.partition('.')
+        decimal = (decimal + '00')[:2]
+        fs = f'{integer}.{decimal} {unit}'
+
+    return f'{fs:>9}'
 
 
 def _channel(x: str) -> str: