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

recs/cfg/cli.py

@@ -1,37 +1,17 @@
 import string
-import sys
 from pathlib import Path
 
-import click
 import dtyper
 from typer import Argument, rich_utils
 
-from recs.base import RecsError, pyproject
+from recs.base import types
 from recs.base.cfg_raw import CfgRaw
 
-from .cfg import Cfg
+from . import app, cfg
 
 rich_utils.STYLE_METAVAR = 'dim yellow'
-INTRO = f"""
-  {pyproject.message()}
-
-============================================="""
-LINES = (
-    INTRO,
-    'Why should there be a record button at all?',
-    'I wanted to digitize a huge number of cassettes and LPs, so I wanted a '
-    + 'program that ran in the background and recorded everything except quiet.',
-    'Nothing like that existed so I wrote it.  Free, open-source, configurable.',
-    'Full documentation here: https://github.com/rec/recs',
-    '',
-)
-HELP = '\n\n\n\n'.join(LINES)
 # Three blank lines seems to force Typer to format correctly
 
-app = dtyper.Typer(
-    add_completion=False,
-    context_settings={'help_option_names': ['--help', '-h']},
-)
 _SINGLES: set[str] = set()
 
 RECS = CfgRaw()
@@ -43,151 +23,232 @@ def Option(default, *a, **ka) -> dtyper.Option:
     return dtyper.Option(default, *a, **ka)
 
 
-@app.command(help=HELP)
+GENERAL_PANEL = 'Options'  # 'General Settings'
+SUBCOMMANDS_PANEL = 'Subcommands'
+NAMES_PANEL = 'Selecting and Naming Devices and Channels'
+FILE_PANEL = 'Audio File Format Settings'
+CONSOLE_PANEL = 'Console and UI Settings'
+RECORD_PANEL = 'Record Settings'
+
+
+@app.app.command(help=app.HELP)
 def recs(
     #
     # Directory settings
     #
-    path: Path = Argument(
-        RECS.path, help='Path to the parent directory to create audio files in'
-    ),
-    subdirectory: list[str] = Option(
-        RECS.subdirectory,
-        '-s',
-        '--subdirectory',
-        help='Organize files into subdirectories by channel, device or time.',
+    path: str = Argument(
+        RECS.path, help='Path or path pattern for recorded file locations'
     ),
     #
-    # General purpose settings
+    # General
     #
+    calibrate: bool = Option(
+        RECS.calibrate,
+        '--calibrate',
+        help='Detect and print noise levels, do not record',
+        rich_help_panel=GENERAL_PANEL,
+    ),
     dry_run: bool = Option(
-        RECS.dry_run, '-n', '--dry-run', help='Display levels only, do not record'
+        RECS.dry_run,
+        '-n',
+        '--dry-run',
+        help='Display levels only, do not record',
+        rich_help_panel=GENERAL_PANEL,
+    ),
+    verbose: bool = Option(
+        RECS.verbose,
+        '-v',
+        '--verbose',
+        help='Print more stuff - currently does nothing',
+        rich_help_panel=GENERAL_PANEL,
     ),
+    #
+    # Subcommands
+    #
     info: bool = Option(
-        RECS.info, '--info', help='Do not run, display device info instead'
+        RECS.info,
+        '--info',
+        help='Display device info as JSON',
+        rich_help_panel=SUBCOMMANDS_PANEL,
     ),
     list_types: bool = Option(
-        RECS.list_types, help='List all subtypes for each format'
-    ),
-    verbose: bool = Option(
-        RECS.verbose, '-v', '--verbose', help='Print full stack traces'
+        RECS.list_types,
+        '--list-types',
+        help='List all subtypes for each format as JSON',
+        rich_help_panel=SUBCOMMANDS_PANEL,
     ),
     #
-    # Aliases for input devices or channels
+    # Names
     #
     alias: list[str] = Option(
-        RECS.alias, '-a', '--alias', help='Aliases for devices or channels'
+        RECS.alias,
+        '-a',
+        '--alias',
+        click_type=app.AliasParam(),
+        help='Set aliases for devices or channels',
+        rich_help_panel=NAMES_PANEL,
+    ),
+    devices: Path = Option(
+        RECS.devices,
+        help='A path to a JSON file with device definitions',
+        rich_help_panel=NAMES_PANEL,
     ),
-    devices: Path = Option(RECS.devices, help='A JSON file with device definitions'),
-    #
-    # Exclude or include devices or channels
-    #
     exclude: list[str] = Option(
-        RECS.exclude, '-e', '--exclude', help='Exclude these devices or channels'
+        RECS.exclude,
+        '-e',
+        '--exclude',
+        help='Exclude devices or channels',
+        rich_help_panel=NAMES_PANEL,
     ),
     include: list[str] = Option(
-        RECS.include, '-i', '--include', help='Only include these devices or channels'
+        RECS.include,
+        '-i',
+        '--include',
+        help='Only include these devices or channels',
+        rich_help_panel=NAMES_PANEL,
     ),
     #
-    # Audio file data
+    # File
     #
-    format: str = Option(RECS.format, '-f', '--format', help='Audio format'),
-    metadata: list[str] = Option(
-        RECS.metadata, '-m', '--metadata', help='Metadata fields to add to output files'
+    format: types.Format = Option(
+        RECS.format,
+        '-f',
+        '--format',
+        click_type=app.FormatParam(),
+        help='Audio file format',
+        rich_help_panel=FILE_PANEL,
     ),
-    sdtype: str = Option(
-        RECS.sdtype, '-d', '--sdtype', help='Type of sounddevice numbers'
+    metadata: list[str] = Option(
+        RECS.metadata,
+        '-m',
+        '--metadata',
+        click_type=app.MetadataParam(),
+        help='Metadata fields to add to output files',
+        rich_help_panel=FILE_PANEL,
+    ),
+    sdtype: types.SdType
+    | None = Option(
+        RECS.sdtype,
+        '-d',
+        '--sdtype',
+        click_type=app.SdTypeParam(),
+        help='Integer or float number type for recording',
+        rich_help_panel=FILE_PANEL,
+    ),
+    subtype: types.Subtype
+    | None = Option(
+        RECS.subtype,
+        '-u',
+        '--subtype',
+        click_type=app.SubtypeParam(),
+        help='Audio file subtype',
+        rich_help_panel=FILE_PANEL,
     ),
-    subtype: str = Option(RECS.subtype, '-u', '--subtype', help='File subtype'),
     #
-    # Console and UI settings
+    # Console
     #
+    clear: bool = Option(
+        RECS.clear,
+        '-r',
+        '--clear',
+        help='Clear display on shutdown',
+        rich_help_panel=CONSOLE_PANEL,
+    ),
     silent: bool = Option(
-        RECS.silent, '-q', '--silent', help='If true, do not display live updates'
+        RECS.silent,
+        '-s',
+        '--silent',
+        help='Do not display live updates',
+        rich_help_panel=CONSOLE_PANEL,
     ),
-    retain: bool = Option(
-        RECS.retain, '-r', '--retain', help='Retain rich display on shutdown'
+    sleep_time_device: str = Option(
+        RECS.sleep_time_device,
+        '--sleep-time-device',
+        click_type=app.TimeParam(),
+        help='How long to sleep between checking device',
+        rich_help_panel=CONSOLE_PANEL,
     ),
     ui_refresh_rate: float = Option(
         RECS.ui_refresh_rate,
         '--ui-refresh-rate',
         help='How many UI refreshes per second',
-    ),
-    sleep_time: float = Option(
-        RECS.sleep_time, '--sleep-time', help='How long to sleep between data refreshes'
+        rich_help_panel=CONSOLE_PANEL,
     ),
     #
-    # Settings relating to times
+    # Record
     #
     infinite_length: bool = Option(
         RECS.infinite_length,
-        help='If true, ignore file size limits (4G on .wav, 2G on .aiff)',
+        '--infinite-length',
+        help='Ignore file size limits (4G on .wav, 2G on .aiff)',
+        rich_help_panel=RECORD_PANEL,
     ),
     longest_file_time: str = Option(
-        RECS.longest_file_time, help='Longest amount of time per file: 0 means infinite'
+        RECS.longest_file_time,
+        click_type=app.TimeParam(),
+        help='Longest amount of time per file: 0 means infinite',
+        rich_help_panel=RECORD_PANEL,
     ),
-    moving_average_time: float = Option(
-        RECS.moving_average_time, help='How long to average the volume display over'
+    moving_average_time: str = Option(
+        RECS.moving_average_time,
+        click_type=app.TimeParam(),
+        help='How long to average the volume display over',
+        rich_help_panel=RECORD_PANEL,
     ),
     noise_floor: float = Option(
-        RECS.noise_floor, '-o', '--noise-floor', help='The noise floor in decibels'
+        RECS.noise_floor,
+        '-o',
+        '--noise-floor',
+        help='The noise floor in decibels',
+        rich_help_panel=RECORD_PANEL,
     ),
     shortest_file_time: str = Option(
-        RECS.shortest_file_time, help='Shortest amount of time per file'
+        RECS.shortest_file_time,
+        click_type=app.TimeParam(),
+        help='Shortest amount of time per file',
+        rich_help_panel=RECORD_PANEL,
     ),
-    quiet_after_end: float = Option(
+    quiet_after_end: str = Option(
         RECS.quiet_after_end,
         '-c',
         '--quiet-after-end',
-        help='Quiet after the end, in seconds',
+        click_type=app.TimeParam(),
+        help='How much quiet after the end',
+        rich_help_panel=RECORD_PANEL,
     ),
-    quiet_before_start: float = Option(
+    quiet_before_start: str = Option(
         RECS.quiet_before_start,
         '-b',
         '--quiet-before-start',
-        help='Quiet before the start, in seconds',
+        click_type=app.TimeParam(),
+        help='How much quiet before a recording',
+        rich_help_panel=RECORD_PANEL,
     ),
-    stop_after_quiet: float = Option(
+    stop_after_quiet: str = Option(
         RECS.stop_after_quiet,
         '--stop-after-quiet',
-        help='Stop recs after quiet',
+        click_type=app.TimeParam(),
+        help='How much quiet before stopping a recording',
+        rich_help_panel=RECORD_PANEL,
     ),
-    total_run_time: float = Option(
+    total_run_time: str = Option(
         RECS.total_run_time,
         '-t',
         '--total-run-time',
+        click_type=app.TimeParam(),
         help='How many seconds to record? 0 means forever',
+        rich_help_panel=RECORD_PANEL,
     ),
-) -> None:  # pragma: no cover: This is tested in a subprocess.
-    cfg = Cfg(**locals())
+) -> None:
+    c = cfg.Cfg(**locals())
 
-    from . import run
+    from . import run_cli
 
-    run.run(cfg)
+    run_cli.run_cli(c)
 
 
 _USED_SINGLES = ''.join(sorted(_SINGLES))
 _UNUSED_SINGLES = ''.join(sorted(set(string.ascii_lowercase) - set(_SINGLES)))
 
-assert _USED_SINGLES == 'abcdefimnoqrstuv', _USED_SINGLES
-assert _UNUSED_SINGLES == 'ghjklpwxyz', _UNUSED_SINGLES
-
-
-def run() -> int:
-    try:
-        app(standalone_mode=False)
-        return 0
-
-    except RecsError as e:
-        print('ERROR:', *e.args, file=sys.stderr)
-
-    except click.ClickException as e:
-        print(f'{e.__class__.__name__}: {e.message}', file=sys.stderr)
-
-    except click.Abort:
-        print('Aborted', file=sys.stderr)
-
-    except KeyboardInterrupt:
-        print('Interrupted', file=sys.stderr)
-
-    return -1
+assert _USED_SINGLES == 'abcdefimnorstuv', _USED_SINGLES
+assert _UNUSED_SINGLES == 'ghjklpqwxyz', _UNUSED_SINGLES

recs/cfg/device.py

@@ -8,10 +8,27 @@ import numpy as np
 
 from recs.base import times
 from recs.base.prefix_dict import PrefixDict
-from recs.base.types import DeviceDict, SdType
-from recs.misc import hash_cmp
+from recs.base.types import DeviceDict, SdType, Stop
+from recs.cfg import hash_cmp
 
-Callback = t.Callable[[np.ndarray, float], None]
+
+class Update(t.NamedTuple):
+    array: np.ndarray
+    timestamp: float
+
+
+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):
@@ -25,64 +42,34 @@ class InputDevice(hash_cmp.HashCmp):
     def __str__(self) -> str:
         return self.name
 
-    @property
-    def is_online(self) -> bool:
-        # TODO: this is wrong!
-        # https://github.com/spatialaudio/python-sounddevice/issues/382
-        # return any(self.name == i['name'] for i in sd.query_devices())
-        return True
-
     def input_stream(
-        self,
-        callback: Callback,
-        dtype: SdType,
-        stop: t.Callable[[], None],
-    ) -> t.Iterator[None] | None:
+        self, device_callback: DeviceCallback, sdtype: SdType, on_error: Stop
+    ) -> InputStream:
         import sounddevice as sd
 
-        if not self.is_online:
-            return None
-
         stream: sd.InputStream
 
-        def cb(indata: np.ndarray, frames: int, _time: float, status: int) -> None:
-            # TODO: time is a _cffi_backend._CDataBase, not a float!
-
-            stream._recs_timestamp = times.time()
-
+        def callback(indata: np.ndarray, frames: int, time: t.Any, status: int) -> None:
             if status:  # pragma: no cover
-                # This has not yet happened, probably because we never get behind
-                # the device callback cycle.
                 print('Status', self, status, file=sys.stderr)
 
-            if not indata.size:  # pragma: no cover
-                print('Empty block', self, file=sys.stderr)
-                return
-
             try:
-                # `indata` is always the same variable!
-                callback(indata.copy(), stream._recs_timestamp)
+                device_callback(Update(indata.copy(), times.timestamp()))
 
             except Exception:  # pragma: no cover
                 traceback.print_exc()
                 try:
-                    stream.stop()
-                except Exception:
-                    traceback.print_exc()
-                try:
-                    stop()
+                    on_error()
                 except Exception:
                     traceback.print_exc()
 
-        assert dtype is not None  # If sdtype is None, then the whole system blocks
         stream = sd.InputStream(
-            callback=cb,
+            callback=callback,
             channels=self.channels,
             device=self.name,
-            dtype=dtype,
+            dtype=sdtype,
             samplerate=self.samplerate,
         )
-        stream._recs_timestamp = times.time()
         return stream
 
 
@@ -90,16 +77,23 @@ InputDevices = PrefixDict[InputDevice]
 
 
 def get_input_devices(devices: t.Sequence[DeviceDict]) -> InputDevices:
-    return PrefixDict({d.name: d for i in devices if (d := InputDevice(i))})
+    return PrefixDict({d.name: d for i in devices if (d := InputDevice(i)).channels})
 
 
-P = 'import json, sounddevice; print(json.dumps(sounddevice.query_devices(), indent=4))'
+CMD = sys.executable, '-m', 'recs.base._query_device'
 
 
 def query_devices() -> t.Sequence[DeviceDict]:
-    r = sp.run(('python', '-c', P), text=True, check=True, stdout=sp.PIPE)
+    try:
+        r = sp.run(CMD, text=True, check=True, stdout=sp.PIPE)
+    except sp.CalledProcessError:
+        return []
     return json.loads(r.stdout)
 
 
+def input_names() -> t.Sequence[str]:
+    return sorted(str(i['name']) for i in query_devices())
+
+
 def input_devices() -> InputDevices:
     return get_input_devices(query_devices())

recs/{base → cfg}/metadata.py

@@ -2,13 +2,16 @@ import typing as t
 
 import soundfile as sf
 
-from . import RecsError
+from recs.base import RecsError, prefix_dict
+from recs.base.types import Format
 
 RECS_USES = {'date', 'software', 'tracknumber'}
 USABLE = {'album', 'artist', 'comment', 'copyright', 'genre', 'title'}
 UNUSABLE = {'license'}  # Can't be set for some reason
 ALL = RECS_USES | USABLE | UNUSABLE
 
+PREFIX_DICT = prefix_dict.PrefixDict({i: i for i in sorted(ALL)})
+
 
 def to_dict(metadata: t.Sequence[str]) -> dict[str, str]:
     result: dict[str, str] = {}
@@ -16,6 +19,12 @@ def to_dict(metadata: t.Sequence[str]) -> dict[str, str]:
 
     for m in metadata:
         name, eq, value = (i.strip() for i in m.partition('='))
+
+        try:
+            name = PREFIX_DICT[name]
+        except KeyError:
+            pass
+
         if not (name and eq and value):
             errors.setdefault('malformed', []).append(m)
         elif name in result:
@@ -29,10 +38,22 @@ def to_dict(metadata: t.Sequence[str]) -> dict[str, str]:
 
     if errors:
         msg = ', '.join(f'{k}: {v}' for k, v in errors.items())
-        raise RecsError('Metadata: ' + msg)
+        raise RecsError(msg)
 
     return result
 
 
 def get_metadata(fp: sf.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

@@ -0,0 +1,156 @@
+import re
+import string
+from datetime import datetime
+from enum import IntEnum, auto
+
+from recs.base import RecsError
+from recs.cfg import aliases, track
+
+findall_strftime = re.compile('%.').findall
+
+
+def parse_fields(s: str) -> list[str]:
+    return sorted(n for _, n, _, _ in string.Formatter().parse(s) if n)
+
+
+class Req(IntEnum):
+    device = auto()
+    channel = auto()
+    year = auto()
+    month = auto()
+    day = auto()
+    hour = auto()
+    minute = auto()
+    second = auto()
+
+
+class PathPattern:
+    def __init__(self, path: str) -> None:
+        str_parts = parse_fields(path)
+        time_parts = findall_strftime(path)
+        parts = set(time_parts + str_parts)
+
+        if bad := parts - FIELDS:
+            raise RecsError(f'Unknown: {", ".join(sorted(bad))}')
+
+        self.name_parts = tuple(i for i in str_parts if i not in FIELD_TO_PSTRING)
+        self.pstring_parts = tuple(i for i in str_parts if i in FIELD_TO_PSTRING)
+
+        used = set().union(*(FIELD_TO_REQUIRED[p] for p in parts))
+        unused = set(Req) - used
+
+        def rep(r: Req) -> str:
+            return (r in unused) * f'{{{r.name}}}'
+
+        y, m, d = rep(Req.year), rep(Req.month), rep(Req.day)
+        if (m and not (y or d)) or (not m and (y and d)):
+            raise RecsError(f'Must specify year or day with month: {path}')
+        date = y + m + d
+
+        h, m, s = rep(Req.hour), rep(Req.minute), rep(Req.second)
+        if (m and not (h or s)) or (not m and (h and s)):
+            raise RecsError(f'Must specify hour or second with minute: {path}')
+        time = h + m + s
+
+        d, c = rep(Req.device), rep(Req.channel)
+        dc = '{track}' if all((d, c)) else d + c
+
+        dt = f'{date}-{time}' if all((date, time)) else date + time
+        p = f'{dc} + {dt}' if all((dc, dt)) else dc + dt
+
+        self.path = f'{path}/{p}' if all((path, p)) else path + p
+
+        str_parts = parse_fields(self.path)
+        self.strf_parts = tuple(i for i in str_parts if i in FIELD_TO_PSTRING)
+
+    def times(self, ts: datetime) -> dict[str, str]:
+        return {k: ts.strftime(FIELD_TO_PSTRING[k]) for k in self.strf_parts}
+
+    def evaluate(
+        self,
+        track: track.Track,
+        aliases: aliases.Aliases,
+        timestamp: float,
+        index: int,
+    ) -> str:
+        ts = datetime.fromtimestamp(timestamp)
+        s = ts.strftime(self.path)
+
+        return s.format(
+            channel=track.name,
+            device=aliases.display_name(track.device),
+            index=str(index),
+            track=aliases.display_name(track, short=False),
+            **self.times(ts),
+        )
+
+
+DATE = {Req.year, Req.month, Req.day}
+TIME = {Req.hour, Req.minute, Req.second}
+
+FIELD_TO_REQUIRED: dict[str, set[Req]] = {
+    'index': DATE | TIME,
+    'device': {Req.device},
+    'channel': {Req.channel},
+    'track': {Req.channel, Req.device},
+    #
+    'date': DATE,
+    'time': TIME,
+    'ddate': DATE,
+    'dtime': TIME,
+    'sdate': DATE,
+    'stime': TIME,
+    'timestamp': DATE | TIME,
+    #
+    'year': {Req.year},
+    'month': {Req.month},
+    'day': {Req.day},
+    'hour': {Req.hour},
+    'minute': {Req.minute},
+    'second': {Req.second},
+    #
+    '%A': set(),
+    '%B': {Req.month},
+    '%G': {Req.year},
+    '%H': {Req.hour},
+    '%I': set(),
+    '%M': {Req.minute},
+    '%S': {Req.second},
+    '%U': set(),
+    '%V': set(),
+    '%W': set(),
+    '%X': TIME,
+    '%Y': {Req.year},
+    '%Z': set(),
+    '%a': set(),
+    '%b': {Req.month},
+    '%c': DATE | TIME,
+    '%d': {Req.day},
+    '%f': set(),
+    '%j': {Req.month, Req.day},
+    '%m': {Req.month},
+    '%p': set(),
+    '%u': set(),
+    '%w': set(),
+    '%x': DATE,
+    '%y': {Req.year},
+    '%%': set(),
+}
+FIELDS = set(FIELD_TO_REQUIRED)
+
+FIELD_TO_PSTRING: dict[str, str] = {
+    'date': '%Y%m%d',
+    'time': '%H%M%S',
+    'ddate': '%Y-%m-%d',
+    'dtime': '%H-%M-%S',
+    'sdate': '%Y/%m/%d',
+    'stime': '%H/%M/%S',
+    'timestamp': '%H%M%S_Y%m%d',
+    #
+    'year': '%Y',
+    'month': '%m',
+    'day': '%d',
+    'hour': '%H',
+    'minute': '%M',
+    'second': '%S',
+}