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

recs/cfg/__init__.py

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

recs/cfg/aliases.py

@@ -1,6 +1,8 @@
 import typing as t
 
 from recs.base.prefix_dict import PrefixDict
+from recs.base import prefix_dict, RecsError
+
 
 from .device import InputDevice, InputDevices
 from .track import Track
@@ -8,9 +10,11 @@ from .track import Track
 CHANNEL_SPLITTER = '+'
 
 
-class Aliases(PrefixDict[Track]):
+class Aliases:
+    tracks: prefix_dict.PrefixDict[Track]
+
     def __init__(self, aliases: t.Sequence[str], devices: InputDevices) -> None:
-        super().__init__()
+        self.tracks = PrefixDict()
 
         assert devices
         self.devices = devices
@@ -25,57 +29,64 @@ class Aliases(PrefixDict[Track]):
 
         names, values = zip(*(split(n) for n in aliases))
         if len(set(names)) < len(names):
-            raise ValueError(f'Duplicate aliases: {aliases}')
+            raise RecsError(f'Duplicate aliases: {aliases}')
 
-        self.update(sorted(zip(names, self.to_tracks(values))))
+        self.tracks.update(sorted(zip(names, self.to_tracks(values))))
 
         inv: dict[Track, list[str]] = {}
-        for k, v in self.items():
+        for k, v in self.tracks.items():
             inv.setdefault(v, []).append(k)
 
         if duplicate_aliases := [(k, v) for k, v in inv.items() if len(v) > 1]:
-            raise ValueError(f'Duplicate alias values: {duplicate_aliases}')
+            raise RecsError(f'Duplicate alias values: {duplicate_aliases}')
 
         self.inv = {k: v[0] for k, v in sorted(inv.items())}
 
     def to_tracks(self, names: t.Iterable[str]) -> t.Sequence[Track]:
-        bad_track_names = []
+        errors: dict[str, list[str]] = {}
         result: list[Track] = []
 
         for name in names:
             try:
                 result.append(self.to_track(name))
-            except Exception:
-                bad_track_names.append(name)
+            except KeyError as e:
+                key, error = e.args
+                errors.setdefault(error, []).append(key)
+
+        if not errors:
+            return result
 
-        if bad_track_names:
-            s = 's' * (len(bad_track_names) != 1)
-            raise ValueError(f'Bad device name{s}: {", ".join(bad_track_names)}')
+        def err(k, v) -> str:
+            s = 's' * (len(v) != 1)
+            return f'{k.capitalize()} device name{s}: {", ".join(v)}'
 
-        return result
+        devs = '", "'.join(sorted(self.devices))
+        devices = f'Devices: "{devs}"'
+        errs = (err(k, v) for k, v in errors.items())
 
-    def display_name(self, x: InputDevice | Track) -> str:
+        raise RecsError('\n'.join([*errs, devices]))
+
+    def display_name(self, x: InputDevice | Track, short: bool = True) -> str:
         if isinstance(x, InputDevice):
             return self.inv.get(Track(x), x.name)
-        else:
-            return self.inv.get(x, x.channels_name)
+
+        default = x.name if short else str(x)
+        return self.inv.get(x, default)
 
     def to_track(self, track_name: str) -> Track:
         try:
-            return self[track_name]
+            return self.tracks[track_name]
         except KeyError:
             pass
 
         name, _, channels = (i.strip() for i in track_name.partition(CHANNEL_SPLITTER))
         try:
-            track = self[name]
+            track = self.tracks[name]
         except KeyError:
             device = self.devices[name]
         else:
             if track.channels:
-                raise KeyError(
-                    f'Alias {name} is a device alias: "{track_name}" is not legal'
-                )
+                raise KeyError(track_name, 'impossible')
             device = track.device
 
         return Track(device, channels)

recs/cfg/app.py

@@ -0,0 +1,87 @@
+import click
+import dtyper
+
+from recs.base import RecsError, pyproject, times
+from recs.base.type_conversions import FORMATS, SDTYPES, SUBTYPES
+
+from . import metadata
+
+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)
+
+app = dtyper.Typer(
+    add_completion=False,
+    context_settings={'help_option_names': ['--help', '-h']},
+)
+
+
+class TimeParam(click.ParamType):
+    name = 'TIME'
+
+    def convert(self, value, p, ctx) -> float:
+        if isinstance(value, (int, float)):
+            return value
+        try:
+            return times.to_time(value)
+        except ValueError as e:
+            self.fail(f'{p.opts[0]}: {e.args[0]}', p, ctx)
+
+
+class DictParam(click.ParamType):
+    name = 'NONE'
+    prefix_dict: dict
+
+    def convert(self, value, p, ctx):
+        if not value:
+            return None
+        if not isinstance(value, str):
+            return value
+        try:
+            return self.prefix_dict[value]
+        except KeyError:
+            self.fail(f'Cannot understand {p.opts[0]}="{value}"')
+
+
+class FormatParam(DictParam):
+    name = 'AUDIO FORMAT'
+    prefix_dict = FORMATS
+
+
+class SdTypeParam(DictParam):
+    name = 'NUMERIC TYPE'
+    prefix_dict = SDTYPES
+
+
+class SubtypeParam(DictParam):
+    name = 'AUDIO SUBTYPE'
+    prefix_dict = SUBTYPES
+
+
+class MetadataParam(click.ParamType):
+    name = 'METADATA'
+
+    def convert(self, value, p, ctx):
+        try:
+            metadata.to_dict([value])
+            return value
+        except RecsError as e:
+            self.fail(f'In {p.opts[0]}: "{e.args[0]}"')
+
+
+class AliasParam(click.ParamType):
+    name = 'ALIAS'
+
+    def convert(self, value, p, ctx):
+        return value

recs/cfg/cfg.py

@@ -1,66 +1,65 @@
 import dataclasses as dc
 import json
+import logging
 import typing as t
 import warnings
 from functools import wraps
 
 import soundfile as sf
 
-from recs.base import RecsError, metadata, times
+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 (
-    FORMATS,
-    SDTYPE_TO_SUBTYPE,
-    SUBTYPE_TO_SDTYPE,
-    SUBTYPES,
-)
-from recs.base.types import SDTYPE, Format, SdType, Subdirectory, Subtype
-
-from . import device
-from .aliases import Aliases
+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
 
-SUBDIRECTORY = PrefixDict({s: s for s in Subdirectory})
+from . import device, metadata, path_pattern, time_settings
+from .aliases import Aliases
 
 
 class Cfg:
     devices: device.InputDevices
     format: Format
-    sdtype: SdType | None = None
-    subtype: Subtype | None = None
+    subtype: Subtype | None
+    sdtype: SdType
 
     @wraps(CfgRaw.__init__)
     def __init__(self, *a, **ka) -> None:
         self.cfg = cfg = CfgRaw(*a, **ka)
 
-        def get(d, key, flag):
-            if not key:
-                return None
-            try:
-                return d[key]
-            except KeyError:
-                raise RecsError(f'Cannot understand --{flag}="{key}"') from None
+        # This constructor has this *global side-effect*, see log.py
+        log.VERBOSE = cfg.verbose
+        if cfg.verbose:
+            logging.basicConfig(level=logging.DEBUG)
 
-        self.format = get(FORMATS, cfg.format, 'format')
-        self.sdtype = get(SdType, cfg.sdtype, 'sdtype')
-        self.subtype = get(SUBTYPES, cfg.subtype, 'subtype')
+        self.path = path_pattern.PathPattern(cfg.path)
 
-        if self.subtype:
-            if not self.sdtype:
-                self.sdtype = SUBTYPE_TO_SDTYPE.get(self.subtype, SDTYPE)
+        self.format = t.cast(Format, cfg.format)
 
-            if not sf.check_format(self.format, self.subtype):
-                raise RecsError(f'{self.format} and {self.subtype} are incompatible')
-
-        elif self.sdtype:
-            subtype = SDTYPE_TO_SUBTYPE.get(self.sdtype, None)
+        if cfg.subtype:
+            self.subtype = t.cast(Subtype, cfg.subtype)
+        elif not cfg.sdtype:
+            self.subtype = None
+        else:
+            subtype = SDTYPE_TO_SUBTYPE[t.cast(SdType, cfg.sdtype)]
 
             if sf.check_format(self.format, subtype):
                 self.subtype = subtype
             else:
-                msg = f'format={self.format:s}, sdtype={self.sdtype:s}'
+                self.subtype = None
+                msg = f'format={self.format:s}, sdtype={cfg.sdtype:s}'
                 warnings.warn(f"Can't get subtype for {msg}")
 
+        if self.subtype and not sf.check_format(self.format, self.subtype):
+            raise RecsError(f'{self.format} and {self.subtype} are incompatible')
+
+        if cfg.sdtype:
+            self.sdtype = t.cast(SdType, cfg.sdtype)
+        elif self.subtype:
+            self.sdtype = SUBTYPE_TO_SDTYPE.get(self.subtype, SDTYPE)
+        else:
+            self.sdtype = SDTYPE
+
         if cfg.devices.name:
             if not cfg.devices.exists():
                 raise RecsError(f'{cfg.devices} does not exist')
@@ -73,35 +72,12 @@ class Cfg:
 
         self.aliases = Aliases(cfg.alias, self.devices)
         self.metadata = metadata.to_dict(cfg.metadata)
-        self.subdirectory = self._subdirectory()
         self.times = self._times()
 
     def __getattr__(self, k: str) -> t.Any:
         return getattr(self.cfg, k)
 
-    def _subdirectory(self) -> t.Sequence[Subdirectory]:
-        subs = [(s, SUBDIRECTORY.get_value(s)) for s in self.cfg.subdirectory]
-        res = tuple(t for s, t in subs if t is not None)
-
-        if bad_subdirectories := [s for s, t in subs if t is None]:
-            raise RecsError(f'Bad arguments to --subdirectory: {bad_subdirectories}')
-
-        if len(set(res)) < len(res):
-            raise RecsError('Duplicates in --subdirectory')
-
-        return res
-
-    def _times(self) -> times.TimeSettings:
-        fields = (f.name for f in dc.fields(times.TimeSettings))
+    def _times(self) -> time_settings.TimeSettings:
+        fields = (f.name for f in dc.fields(time_settings.TimeSettings))
         d = {k: getattr(self, k) for k in fields}
-
-        try:
-            d['longest_file_time'] = times.to_time(t := d['longest_file_time'])
-        except (ValueError, TypeError):
-            raise RecsError(f'Do not understand --longest-file-time={t}')
-        try:
-            d['shortest_file_time'] = times.to_time(t := d['shortest_file_time'])
-        except (ValueError, TypeError):
-            raise RecsError(f'Do not understand --shortest-file-time={t}')
-
-        return times.TimeSettings(**d)
+        return time_settings.TimeSettings(**d)