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

recs/cfg/app.py

@@ -1,3 +1,5 @@
+import typing as t
+
 import click
 import dtyper
 
@@ -30,7 +32,7 @@ app = dtyper.Typer(
 class TimeParam(click.ParamType):
     name = 'TIME'
 
-    def convert(self, value, p, ctx) -> float:
+    def convert(self, value: t.Any, p: t.Any, ctx: t.Any) -> float:
         if isinstance(value, (int, float)):
             return value
         try:
@@ -41,9 +43,9 @@ class TimeParam(click.ParamType):
 
 class DictParam(click.ParamType):
     name = 'NONE'
-    prefix_dict: dict
+    prefix_dict: dict[str, t.Any]
 
-    def convert(self, value, p, ctx):
+    def convert(self, value: t.Any, p: t.Any, ctx: t.Any) -> t.Any:
         if not value:
             return None
         if not isinstance(value, str):
@@ -72,7 +74,7 @@ class SubtypeParam(DictParam):
 class MetadataParam(click.ParamType):
     name = 'METADATA'
 
-    def convert(self, value, p, ctx):
+    def convert(self, value: t.Any, p: t.Any, ctx: t.Any) -> t.Any:
         try:
             metadata.to_dict([value])
             return value
@@ -83,5 +85,5 @@ class MetadataParam(click.ParamType):
 class AliasParam(click.ParamType):
     name = 'ALIAS'
 
-    def convert(self, value, p, ctx):
+    def convert(self, value: t.Any, p: t.Any, ctx: t.Any) -> t.Any:
         return value

recs/cfg/cfg.py

@@ -4,11 +4,13 @@ import logging
 import typing as t
 import warnings
 from functools import wraps
+from pathlib import Path
 
-import soundfile as sf
+import soundfile
 
 from recs.base import RecsError
 from recs.base.cfg_raw import CfgRaw
+from recs.base.prefix_dict import PrefixDict
 from recs.base.type_conversions import SDTYPE_TO_SUBTYPE, SUBTYPE_TO_SDTYPE
 from recs.base.types import SDTYPE, Format, SdType, Subtype
 from recs.misc import log
@@ -19,12 +21,12 @@ from .aliases import Aliases
 
 class Cfg:
     devices: device.InputDevices
-    format: Format
+    formats: t.Sequence[Format]
     subtype: Subtype | None
     sdtype: SdType
 
     @wraps(CfgRaw.__init__)
-    def __init__(self, *a, **ka) -> None:
+    def __init__(self, *a: t.Any, **ka: t.Any) -> None:
         self.cfg = cfg = CfgRaw(*a, **ka)
 
         # This constructor has this *global side-effect*, see log.py
@@ -32,9 +34,16 @@ class Cfg:
         if cfg.verbose:
             logging.basicConfig(level=logging.DEBUG)
 
-        self.path = path_pattern.PathPattern(cfg.path)
+        self.output_directory = path_pattern.PathPattern(cfg.output_directory)
 
-        self.format = t.cast(Format, cfg.format)
+        self.files = [Path(f) for f in cfg.files or ()]
+        if not_exist := [f for f in self.files if not f.exists()]:
+            s = 's' * (len(not_exist) != 1)
+            fname = ', '.join(str(f) for f in not_exist)
+            raise RecsError(f'Non-existent file{s}: {fname}')
+
+        assert not isinstance(cfg.formats, str)
+        self.formats = [Format(f) for f in cfg.formats] or [Format._default]
 
         if cfg.subtype:
             self.subtype = t.cast(Subtype, cfg.subtype)
@@ -43,15 +52,15 @@ class Cfg:
         else:
             subtype = SDTYPE_TO_SUBTYPE[t.cast(SdType, cfg.sdtype)]
 
-            if sf.check_format(self.format, subtype):
+            if soundfile.check_format(self.formats[0], subtype):
                 self.subtype = subtype
             else:
                 self.subtype = None
-                msg = f'format={self.format:s}, sdtype={cfg.sdtype:s}'
-                warnings.warn(f"Can't get subtype for {msg}")
+                msg = f'formats={self.formats[0]:s}, sdtype={cfg.sdtype:s}'
+                warnings.warn(f"Can't get subtype for {msg}", stacklevel=2)
 
-        if self.subtype and not sf.check_format(self.format, self.subtype):
-            raise RecsError(f'{self.format} and {self.subtype} are incompatible')
+        if self.subtype and not soundfile.check_format(self.formats[0], self.subtype):
+            raise RecsError(f'{self.formats[0]} and {self.subtype} are incompatible')
 
         if cfg.sdtype:
             self.sdtype = t.cast(SdType, cfg.sdtype)
@@ -60,7 +69,10 @@ class Cfg:
         else:
             self.sdtype = SDTYPE
 
-        if cfg.devices.name:
+        if self.files:
+            self.devices = PrefixDict()
+
+        elif cfg.devices.name:
             if not cfg.devices.exists():
                 raise RecsError(f'{cfg.devices} does not exist')
             devices = json.loads(cfg.devices.read_text())
@@ -77,7 +89,7 @@ class Cfg:
     def __getattr__(self, k: str) -> t.Any:
         return getattr(self.cfg, k)
 
-    def _times(self) -> time_settings.TimeSettings:
+    def _times(self) -> time_settings.TimeSettings[float]:
         fields = (f.name for f in dc.fields(time_settings.TimeSettings))
         d = {k: getattr(self, k) for k in fields}
         return time_settings.TimeSettings(**d)

recs/cfg/cli.py

@@ -1,8 +1,9 @@
 import string
+import typing as t
 from pathlib import Path
 
 import dtyper
-from typer import Argument, rich_utils
+from typer import rich_utils
 
 from recs.base import types
 from recs.base.cfg_raw import CfgRaw
@@ -18,7 +19,7 @@ RECS = CfgRaw()
 # Reading configs and environment variables would go here
 
 
-def Option(default, *a, **ka) -> dtyper.Option:
+def Option(default: t.Any, *a: t.Any, **ka: t.Any) -> t.Any:
     _SINGLES.update(i[1] for i in a if len(i) == 2)
     return dtyper.Option(default, *a, **ka)
 
@@ -33,11 +34,17 @@ RECORD_PANEL = 'Record Settings'
 
 @app.app.command(help=app.HELP)
 def recs(
+    files: list[str] = dtyper.Argument(
+        None, help='One or more files to split for silence'
+    ),
     #
     # Directory settings
     #
-    path: str = Argument(
-        RECS.path, help='Path or path pattern for recorded file locations'
+    output_directory: str = Option(
+        RECS.output_directory,
+        '-o',
+        '--output-directory',
+        help='Path or output_directory pattern for recorded file locations',
     ),
     #
     # General
@@ -59,7 +66,7 @@ def recs(
         RECS.verbose,
         '-v',
         '--verbose',
-        help='Print more stuff - currently does nothing',
+        help='Print more stuff',
         rich_help_panel=GENERAL_PANEL,
     ),
     #
@@ -110,12 +117,12 @@ def recs(
     #
     # File
     #
-    format: types.Format = Option(
-        RECS.format,
+    formats: t.List[types.Format] = Option(
+        tuple(RECS.formats),
         '-f',
-        '--format',
+        '--formats',
         click_type=app.FormatParam(),
-        help='Audio file format',
+        help='Audio file formats',
         rich_help_panel=FILE_PANEL,
     ),
     metadata: list[str] = Option(
@@ -126,8 +133,7 @@ def recs(
         help='Metadata fields to add to output files',
         rich_help_panel=FILE_PANEL,
     ),
-    sdtype: types.SdType
-    | None = Option(
+    sdtype: types.SdType | None = Option(
         RECS.sdtype,
         '-d',
         '--sdtype',
@@ -135,8 +141,7 @@ def recs(
         help='Integer or float number type for recording',
         rich_help_panel=FILE_PANEL,
     ),
-    subtype: types.Subtype
-    | None = Option(
+    subtype: types.Subtype | None = Option(
         RECS.subtype,
         '-u',
         '--subtype',
@@ -177,10 +182,17 @@ def recs(
     #
     # Record
     #
+    band_mode: bool = Option(
+        RECS.band_mode,
+        '--band-mode',
+        '-B',
+        help='Band mode: any track starting starts them all',
+        rich_help_panel=RECORD_PANEL,
+    ),
     infinite_length: bool = Option(
         RECS.infinite_length,
         '--infinite-length',
-        help='Ignore file size limits (4G on .wav, 2G on .aiff)',
+        help='Ignore file size limit: 4G on .wav',
         rich_help_panel=RECORD_PANEL,
     ),
     longest_file_time: str = Option(
@@ -197,15 +209,22 @@ def recs(
     ),
     noise_floor: float = Option(
         RECS.noise_floor,
-        '-o',
+        '-z',
         '--noise-floor',
         help='The noise floor in decibels',
         rich_help_panel=RECORD_PANEL,
     ),
+    record_everything: bool = Option(
+        RECS.record_everything,
+        '-R',
+        '--record-everything',
+        help='Start immediately, record everything until end',
+        rich_help_panel=RECORD_PANEL,
+    ),
     shortest_file_time: str = Option(
         RECS.shortest_file_time,
         click_type=app.TimeParam(),
-        help='Shortest amount of time per file',
+        help='Files shorter than this duration get deleted',
         rich_help_panel=RECORD_PANEL,
     ),
     quiet_after_end: str = Option(
@@ -250,5 +269,5 @@ def recs(
 _USED_SINGLES = ''.join(sorted(_SINGLES))
 _UNUSED_SINGLES = ''.join(sorted(set(string.ascii_lowercase) - set(_SINGLES)))
 
-assert _USED_SINGLES == 'abcdefimnorstuv', _USED_SINGLES
-assert _UNUSED_SINGLES == 'ghjklpqwxyz', _UNUSED_SINGLES
+assert _USED_SINGLES == 'BRabcdefimnorstuvz', _USED_SINGLES
+assert _UNUSED_SINGLES == 'ghjklpqwxy', _UNUSED_SINGLES

recs/cfg/device.py

@@ -5,72 +5,60 @@ import traceback
 import typing as t
 
 import numpy as np
+from overrides import override
+from threa import Runnable, Wrapper
 
 from recs.base import times
 from recs.base.prefix_dict import PrefixDict
-from recs.base.types import DeviceDict, SdType, Stop
-from recs.cfg import hash_cmp
+from recs.base.types import SdType
 
+from .source import Source, Update
 
-class Update(t.NamedTuple):
-    array: np.ndarray
-    timestamp: float
+DeviceDict = dict[str, float | int | str]
 
 
-DeviceCallback = t.Callable[[Update], None]
-
-
-class InputStream(t.Protocol):
-    def close(self, ignore_errors=True) -> None:
-        pass
-
-    def start(self) -> None:
-        pass
-
-    def stop(self, ignore_errors=True) -> None:
-        pass
-
-
-class InputDevice(hash_cmp.HashCmp):
+class InputDevice(Source):
     def __init__(self, info: DeviceDict) -> None:
         self.info = info
-        self.channels = t.cast(int, self.info['max_input_channels'])
-        self.samplerate = int(self.info['default_samplerate'])
-        self.name = t.cast(str, self.info['name'])
-        self._key = self.name
-
-    def __str__(self) -> str:
-        return self.name
+        super().__init__(
+            channels=t.cast(int, self.info['max_input_channels']),
+            name=t.cast(str, self.info['name']),
+            samplerate=int(self.info['default_samplerate']),
+        )
 
+    @override
     def input_stream(
-        self, device_callback: DeviceCallback, sdtype: SdType, on_error: Stop
-    ) -> InputStream:
-        import sounddevice as sd
-
-        stream: sd.InputStream
-
-        def callback(indata: np.ndarray, frames: int, time: t.Any, status: int) -> None:
+        self, sdtype: SdType, update_callback: t.Callable[[Update], None]
+    ) -> Runnable:
+        import sounddevice
+
+        stream: sounddevice.InputStream
+        result: Wrapper
+
+        def callback(
+            indata: np.ndarray,  # type: ignore[type-arg]
+            frames: int,
+            time: t.Any,
+            status: int,
+        ) -> None:
             if status:  # pragma: no cover
                 print('Status', self, status, file=sys.stderr)
 
             try:
-                device_callback(Update(indata.copy(), times.timestamp()))
+                update_callback(Update(indata.copy(), times.timestamp()))
 
             except Exception:  # pragma: no cover
                 traceback.print_exc()
-                try:
-                    on_error()
-                except Exception:
-                    traceback.print_exc()
+                result.stop()
 
-        stream = sd.InputStream(
+        stream = sounddevice.InputStream(
             callback=callback,
             channels=self.channels,
             device=self.name,
             dtype=sdtype,
             samplerate=self.samplerate,
         )
-        return stream
+        return (result := Wrapper(stream))
 
 
 InputDevices = PrefixDict[InputDevice]
@@ -88,7 +76,7 @@ def query_devices() -> t.Sequence[DeviceDict]:
         r = sp.run(CMD, text=True, check=True, stdout=sp.PIPE)
     except sp.CalledProcessError:
         return []
-    return json.loads(r.stdout)
+    return t.cast(list[DeviceDict], json.loads(r.stdout))
 
 
 def input_names() -> t.Sequence[str]:

recs/cfg/file_source.py

@@ -0,0 +1,61 @@
+import traceback
+import typing as t
+from pathlib import Path
+
+import soundfile
+from overrides import override
+from threa import HasThread, Runnable
+
+from recs.base.types import Format, SdType, Subtype
+
+from .source import Source, Update, to_matrix
+
+BLOCKSIZE = 0x1000
+BLOCKCOUNT = 0x1000
+
+
+class FileSource(Source):
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        assert self.path.exists()
+
+        with self._stream() as fp:
+            self.format = Format(fp.format.lower())
+            self.subtype = Subtype(fp.subtype.lower())
+            super().__init__(
+                channels=fp.channels,
+                format=self.format,
+                name=str(path),
+                samplerate=int(fp.samplerate),
+                subtype=self.subtype,
+            )
+
+    def _stream(self) -> soundfile.SoundFile:
+        return soundfile.SoundFile(file=self.path, mode='r')
+
+    @override
+    def input_stream(
+        self, sdtype: SdType, update_callback: t.Callable[[Update], None]
+    ) -> Runnable:
+        result: Runnable
+
+        def input_stream() -> None:
+            try:
+                with self._stream() as fp:
+                    timestamp = 0
+                    for block in fp.blocks(BLOCKSIZE * BLOCKCOUNT):
+                        block = to_matrix(block)
+                        for i in range(BLOCKCOUNT):
+                            array = block[i * BLOCKSIZE : (i + 1) * BLOCKSIZE]
+                            if not array.size:
+                                break
+                            update_callback(Update(array, timestamp / self.samplerate))
+                            timestamp += BLOCKSIZE
+
+            except Exception:
+                traceback.print_exc()
+
+            finally:
+                result.stop()
+
+        return (result := HasThread(input_stream))

recs/cfg/hash_cmp.py

@@ -10,10 +10,10 @@ class HashCmp(ABC):
     def __eq__(self, o: t.Any) -> bool:
         return isinstance(o, type(self)) and self._key == o._key
 
-    def __lt__(self, o) -> bool:
+    def __lt__(self, o: t.Any) -> bool:
         if not isinstance(o, type(self)):
             return NotImplemented
-        return self._key < o._key
+        return bool(self._key < o._key)
 
     def __hash__(self) -> int:
         return hash(self._key)

recs/cfg/metadata.py

@@ -1,6 +1,6 @@
 import typing as t
 
-import soundfile as sf
+import soundfile
 
 from recs.base import RecsError, prefix_dict
 from recs.base.types import Format
@@ -43,17 +43,14 @@ def to_dict(metadata: t.Sequence[str]) -> dict[str, str]:
     return result
 
 
-def get_metadata(fp: sf.SoundFile) -> dict[str, str]:
+def get_metadata(fp: soundfile.SoundFile) -> dict[str, str]:
     return {k: v for k in ALL if (v := getattr(fp, k))}
 
 
 ALLOWS_METADATA = {
-    Format.aiff,
-    Format.caf,
     Format.flac,
     Format.mp3,
     Format.ogg,
     Format.rf64,
     Format.wav,
-    Format.wavex,
 }

recs/cfg/path_pattern.py

@@ -2,6 +2,7 @@ import re
 import string
 from datetime import datetime
 from enum import IntEnum, auto
+from pathlib import Path
 
 from recs.base import RecsError
 from recs.cfg import aliases, track
@@ -26,6 +27,7 @@ class Req(IntEnum):
 
 class PathPattern:
     def __init__(self, path: str) -> None:
+        self.raw_path = path
         str_parts = parse_fields(path)
         time_parts = findall_strftime(path)
         parts = set(time_parts + str_parts)
@@ -66,23 +68,29 @@ class PathPattern:
     def times(self, ts: datetime) -> dict[str, str]:
         return {k: ts.strftime(FIELD_TO_PSTRING[k]) for k in self.strf_parts}
 
-    def evaluate(
+    def make_path(
         self,
         track: track.Track,
         aliases: aliases.Aliases,
         timestamp: float,
         index: int,
-    ) -> str:
+    ) -> Path:
+        if path := getattr(track.source, 'path', None):
+            # It's a file!
+            if not (parent_directory := Path(self.raw_path)).exists():
+                raise FileNotFoundError(f'{parent_directory=}')
+            return parent_directory / f'{path.stem}-{index}'
+
         ts = datetime.fromtimestamp(timestamp)
         s = ts.strftime(self.path)
-
-        return s.format(
+        p = s.format(
             channel=track.name,
-            device=aliases.display_name(track.device),
+            device=aliases.display_name(track.source),
             index=str(index),
             track=aliases.display_name(track, short=False),
             **self.times(ts),
         )
+        return Path(p)
 
 
 DATE = {Req.year, Req.month, Req.day}

recs/cfg/run_cli.py

@@ -1,6 +1,6 @@
 import json
 
-import soundfile as sf
+import soundfile
 
 from recs.base.types import Format, SdType
 from recs.cfg import device
@@ -11,26 +11,17 @@ 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))
+        _info()
+    elif cfg.list_types:
+        _list_types()
+    else:
+        Recorder(cfg).run()
 
 
 def _list_types() -> None:
-    avail = sf.available_formats()
+    avail = soundfile.available_formats()
     fmts = [f.upper() for f in Format]
-    formats = {f: [avail[f], sf.available_subtypes(f)] for f in fmts}
+    formats = {f: [avail[f], soundfile.available_subtypes(f)] for f in fmts}
     sdtypes = [str(s) for s in SdType]
     d = {'formats': formats, 'sdtypes': sdtypes}
 

recs/cfg/source.py

@@ -0,0 +1,42 @@
+import abc
+import typing as t
+
+import numpy as np
+from threa import Runnable
+
+from recs.base.types import Format, SdType, Subtype
+from recs.cfg import hash_cmp
+
+
+def to_matrix(array: np.ndarray) -> np.ndarray:  # type: ignore[type-arg]
+    return array.reshape(*array.shape, 1) if len(array.shape) == 1 else array
+
+
+class Update(t.NamedTuple):
+    array: np.ndarray  # type: ignore[type-arg]
+    timestamp: float
+
+
+class Source(hash_cmp.HashCmp, abc.ABC):
+    def __init__(
+        self,
+        channels: int,
+        name: str,
+        samplerate: int,
+        format: Format | None = None,
+        subtype: Subtype | None = None,
+    ) -> None:
+        self._key = self.name = name
+        self.channels = channels
+        self.format = format
+        self.samplerate = samplerate
+        self.subtype = subtype
+
+    def __str__(self) -> str:
+        return self.name
+
+    @abc.abstractmethod
+    def input_stream(
+        self, sdtype: SdType, update_callback: t.Callable[[Update], None]
+    ) -> Runnable:
+        pass

recs/cfg/time_settings.py

@@ -44,6 +44,9 @@ class TimeSettings(t.Generic[T]):
     #: The noise floor in decibels
     noise_floor: float = 70
 
+    #: Ignore noise_floor, record everything immediately until the end
+    record_everything: bool = False
+
     #: Amount of total time to run.  0 or less means "run forever"
     total_run_time: T = t.cast(T, 0)
 
@@ -51,7 +54,7 @@ class TimeSettings(t.Generic[T]):
     def noise_floor_amplitude(self) -> float:
         return db_to_amplitude(self.noise_floor)
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if negative_fields := [k for k, v in dc.asdict(self).items() if v < 0]:
             raise ValueError(f'TimeSettings cannot be negative: {negative_fields=}')