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

recs/cfg/track.py

@@ -1,22 +1,24 @@
 from recs.base import RecsError
 
 from . import hash_cmp
-from .device import InputDevice
+from .source import Source
 
 __all__ = ('Track',)
 
 
 class Track(hash_cmp.HashCmp):
-    def __init__(self, d: InputDevice, channel: str | tuple[int, ...] = ()) -> None:
-        self.device = d
+    name: str
+
+    def __init__(self, source: Source, channel: str | tuple[int, ...] = ()) -> None:
+        self.source = source
 
         channels = channel or ()
         if isinstance(channels, str):
-            self.channels = _channels(channels, d.name, d.channels)
+            self.channels = _channels(channels, source.name, source.channels)
         else:
             self.channels = channels
 
-        self._key = d.name, self.channels
+        self._key = source.name, self.channels
 
         if self.channels:
             a, b = self.channels[0], self.channels[-1]
@@ -29,11 +31,11 @@ class Track(hash_cmp.HashCmp):
 
     def __str__(self) -> str:
         if self.channels:
-            return f'{self.device.name} + {self.name}'
-        return self.device.name
+            return f'{self.source.name} + {self.name}'
+        return self.source.name
 
     def __repr__(self) -> str:
-        return f'Track(\'{self}\')'
+        return f"Track('{self}')"
 
 
 def _channels(channel: str, device_name: str, max_channels: int) -> tuple[int, ...]:
@@ -54,7 +56,8 @@ def _channels(channel: str, device_name: str, max_channels: int) -> tuple[int, .
             raise ValueError('Channels must be in order')
 
         if channels[-1] > max_channels:
-            raise ValueError(f'Device has only {max_channels} channels')
+            s = '' if max_channels == 1 else 's'
+            raise ValueError(f'Device has only {max_channels} channel{s}')
 
         return channels
 

recs/misc/__init__.py

@@ -1 +0,0 @@
-

recs/misc/contexts.py

@@ -3,7 +3,7 @@ from contextlib import ExitStack, contextmanager
 
 
 @contextmanager
-def contexts(*contexts: t.ContextManager) -> t.Generator:
+def contexts(*contexts: t.ContextManager) -> t.Generator:  # type: ignore[type-arg]
     with ExitStack() as stack:
         for c in contexts:
             stack.enter_context(c)

recs/misc/counter.py

@@ -9,7 +9,9 @@ import numpy as np
 from recs.audio.block import Block
 
 # TODO: isn't there some type comprising these first four?
-Num: t.TypeAlias = int | float | numbers.Integral | numbers.Real | np.ndarray
+Num: t.TypeAlias = (
+    int | float | numbers.Integral | numbers.Real | np.ndarray  # type: ignore[type-arg]
+)
 
 
 @dc.dataclass
@@ -17,11 +19,13 @@ class Counter:
     value: int = 0
     lock: Lock = dc.field(default_factory=Lock)
 
-    def __call__(self, i: int = 1) -> int:
+    def accumulate(self, i: int = 1) -> int:
         with self.lock:
             self.value += i
             return self.value
 
+    __call__ = accumulate  # deprecated
+
 
 class Accumulator:
     count: int = 0
@@ -29,7 +33,7 @@ class Accumulator:
     sum: Num
     square_sum: Num
 
-    def __call__(self, x: Num) -> None:
+    def accumulate(self, x: Num) -> None:
         self.value = x
         try:
             self.sum += x
@@ -40,6 +44,8 @@ class Accumulator:
             self.square_sum += x * x
         self.count += 1
 
+    __call__ = accumulate  # deprecated
+
     def mean(self) -> Num:
         return self.count and self.sum / self.count
 
@@ -56,13 +62,15 @@ class MovingBlock:
     def __init__(self, moving_average_time: int):
         self.moving_average_time = moving_average_time
 
-    def __call__(self, b: Block) -> None:
+    def accumulate(self, b: Block) -> None:
         if self._dq is None:
             maxlen = int(0.5 + self.moving_average_time / len(b))
             self._dq = deque((), maxlen)
 
         self._dq.append(b.amplitude)
 
+    __call__ = accumulate  # deprecated
+
     def mean(self) -> np.ndarray:
         if not self._dq:
             return np.array([0])

recs/misc/file_list.py

@@ -24,7 +24,7 @@ class FileList(list[Path]):
         return self._total_size + _getsize(self[-1])
 
 
-def _getsize(p) -> int:
+def _getsize(p: Path) -> int:
     try:
         return os.path.getsize(p)
     except FileNotFoundError:

recs/misc/log.py

@@ -2,7 +2,7 @@ import os
 import typing as t
 from functools import cache, wraps
 
-C = t.TypeVar('C', bound=t.Callable)
+C = t.TypeVar('C', bound=t.Callable[..., t.Any])
 
 DISABLE = False
 
@@ -12,15 +12,15 @@ VERBOSE = not False
 
 
 @cache
-def _logger():
+def _logger() -> t.TextIO:
     return open(f'/tmp/log-{os.getpid()}.txt', 'w')
 
 
-def log(*a, **ka) -> None:
+def log(*a: t.Any, **ka: t.Any) -> None:
     print(*a, **ka, file=_logger())
 
 
-def verbose(*a, **ka) -> None:
+def verbose(*a: t.Any, **ka: t.Any) -> None:
     if VERBOSE:
         log(*a, **ka)
 
@@ -30,7 +30,7 @@ def logged(function: C) -> C:
         return function
 
     @wraps(function)
-    def wrapped(*args, **kwargs):
+    def wrapped(*args: t.Any, **kwargs: t.Any) -> t.Any:
         verbose(function, 'before')
         try:
             return function(*args, **kwargs)

recs/ui/full_state.py

@@ -2,15 +2,15 @@ import typing as t
 
 from recs.base import state, times
 from recs.base.types import Active
-from recs.cfg import InputDevice, Track
+from recs.cfg import Source, 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}
+    def __init__(self, tracks: t.Sequence[tuple[Source, t.Sequence[Track]]]) -> None:
+        def device_state(tr: t.Sequence[Track]) -> dict[str, state.ChannelState]:
+            return {i.name: state.ChannelState() for i in tr}
 
-        self.state = {k.name: device_state(v) for k, v in tracks.items()}
+        self.state = {k.name: device_state(v) for k, v in tracks}
         self.total = state.ChannelState()
         self.start_time = times.timestamp()
 
@@ -18,7 +18,7 @@ class FullState:
     def elapsed_time(self) -> float:
         return times.timestamp() - self.start_time
 
-    def update(self, state: dict[str, dict[str, state.ChannelState]]) -> None:
+    def update(self, state: t.Mapping[str, t.Mapping[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
@@ -48,3 +48,8 @@ class FullState:
                     'file_count': s.file_count,
                     'volume': len(s.volume) and sum(s.volume) / len(s.volume),
                 }
+
+    def db_ranges(self) -> dict[str, float]:
+        items = self.state.items()
+        d = {f'{k} - {k2}': v2.db_range for k, v in items for k2, v2 in v.items()}
+        return d | {'(all)': self.total.db_range}

recs/ui/live.py

@@ -13,15 +13,15 @@ from recs.cfg import Cfg
 
 from .table import TableFormatter, to_str
 
-RowsFunction = t.Callable[[], t.Iterator[dict[str, t.Any]]]
-
 CONSOLE = Console(color_system='truecolor')
 
 
 class Live(Runnable):
     _last_update_time: float = 0
 
-    def __init__(self, rows: RowsFunction, cfg: Cfg) -> None:
+    def __init__(
+        self, rows: t.Callable[[], t.Iterator[t.Mapping[str, t.Any]]], cfg: Cfg
+    ) -> None:
         self.rows = rows
         self.cfg = cfg
         super().__init__()
@@ -53,7 +53,7 @@ class Live(Runnable):
         super().stop()
 
 
-def _rgb(r=0, g=0, b=0) -> str:
+def _rgb(r: int = 0, g: int = 0, b: int = 0) -> str:
     r, g, b = (int(i) % 256 for i in (r, g, b))
     return f'[rgb({r},{g},{b})]'
 
@@ -67,9 +67,9 @@ def _on(active: Active) -> str:
         return ''
 
 
-def _volume(x) -> str:
+def _volume(x: t.Any) -> str:
     try:
-        s = sum(x) / len(x)
+        s: float = sum(x) / len(x)
     except Exception:
         s = x
 
@@ -78,15 +78,15 @@ def _volume(x) -> str:
 
     if s < 1 / 3:
         r = 0
-        g = 3 * s
+        g = round(3 * s)
     else:
-        r = (3 * s - 1) / 2
+        r = round((3 * s - 1) / 2)
         g = 1 - r
 
     return _rgb(r * 256, g * 256) + to_str(x)
 
 
-def _time_to_str(x) -> str:
+def _time_to_str(x: int) -> str:
     if not x:
         return ''
     s = times.to_str(x)

recs/ui/recorder.py

@@ -1,74 +1,65 @@
+import json
+import multiprocessing as mp
 import typing as t
 from multiprocessing import connection
 
-from threa import HasThread, Runnables, IsThread
+from threa import HasThread, Runnables, Wrapper
 
+from recs.base import RecsError
 from recs.cfg import Cfg, device
 
 from . import live
-from .device_process import DeviceProcess
-from .device_recorder import POLL_TIMEOUT
-from .device_tracks import device_tracks
 from .full_state import FullState
+from .source_recorder import POLL_TIMEOUT, SourceRecorder
+from .source_tracks import source_tracks
 
 
 class Recorder(Runnables):
     def __init__(self, cfg: Cfg) -> None:
         super().__init__()
 
-        tracks = device_tracks(cfg)
+        if not (all_tracks := list(source_tracks(cfg))):
+            raise RecsError('No channels selected')
+
         self.cfg = cfg
         self.live = live.Live(self.rows, cfg)
-        self.state = FullState(tracks)
-        self.device_names = DeviceNames(cfg.sleep_time_device)
+        self.state = FullState(all_tracks)
+        self.names = device.input_names()
+        self.connections: list[connection.Connection] = []
+        self.processes: list[mp.Process] = []
+
+        for _, tracks in all_tracks:
+            conn, child = mp.Pipe()
+            self.connections.append(conn)
+            kwargs = {'cfg': cfg.cfg, 'connection': child, 'tracks': tracks}
+            process = mp.Process(target=SourceRecorder, kwargs=kwargs)
+            self.processes.append(process)
 
-        processes = tuple(DeviceProcess(cfg, t) for t in tracks.values())
-        self.connections = {p.connection: p for p in processes}
         ui_time = 1 / self.cfg.ui_refresh_rate
         live_thread = HasThread(
             self.live.update, looping=True, name='LiveUpdate', pre_delay=ui_time
         )
 
-        self.runnables = self.device_names, *processes, live_thread, self.live
-
-    def run_recorder(self) -> None:
-        with self:
-            while self.running:
-                self.receive()
-
-    def finish(self) -> None:
-        for r in reversed(self.runnables):
-            r.finish()
-        self.stop()
+        self.runnables = *(Wrapper(p) for p in self.processes), live_thread, self.live
 
     def rows(self) -> t.Iterator[dict[str, t.Any]]:
-        yield from self.state.rows(self.device_names.names)
-
-    def receive(self) -> None:
-        for conn in connection.wait(list(self.connections), timeout=POLL_TIMEOUT):
-            c = t.cast(connection.Connection, conn)
-            for device_name, msg in c.recv().items():
-                if msg.get('_exit'):
-                    # Not called
-                    device_process = self.connections[c]
-                    device_process.set_sent()
-                    print('Recorder _exit', device_process.device_name)
-                    self.running = False
-                else:
-                    self.state.update({device_name: msg})
+        yield from self.state.rows(self.names)
 
-        if (rt := self.cfg.total_run_time) and rt <= self.state.elapsed_time:
-            self.stop()
+    def run(self) -> None:
+        try:
+            self._run()
+        finally:
+            if self.cfg.calibrate or self.cfg.verbose:
+                print(json.dumps(self.state.db_ranges(), indent=2))
 
-
-class DeviceNames(IsThread):
-    daemon = True
-    looping = True
-
-    def __init__(self, pre_delay: float) -> None:
-        self.pre_delay = pre_delay
-        super().__init__()
-        self.callback()
-
-    def callback(self) -> None:
-        self.names = device.input_names()
+    def _run(self) -> None:
+        with self:
+            while self.running and all(p.is_alive() for p in self.processes):
+                for c in connection.wait(self.connections, timeout=POLL_TIMEOUT):
+                    conn = t.cast(connection.Connection, c)
+                    try:
+                        msg = conn.recv()
+                    except EOFError:
+                        pass
+                    else:
+                        self.state.update(msg)

recs/ui/source_recorder.py

@@ -0,0 +1,76 @@
+import contextlib
+import os
+import typing as t
+from multiprocessing.connection import Connection
+from queue import Empty, Queue
+
+import numpy as np
+from threa import Runnables
+
+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.cfg.source import Update
+
+NEW_CODE_FLAG = 'RECS_NEW_CODE' in os.environ
+FINISH = 'finish'
+OFFLINE_TIME = 1
+POLL_TIMEOUT = 0.05
+
+
+class SourceRecorder(Runnables):
+    sample_count: int = 0
+
+    def __init__(
+        self,
+        cfg: cfg_raw.CfgRaw,
+        connection: Connection,
+        tracks: t.Sequence[Track],
+    ) -> None:
+        self.cfg = Cfg(**cfg.asdict())
+        self.connection = connection
+
+        self.source = tracks[0].source
+        assert all(t.source == self.source for t in tracks)
+
+        self.name = self.cfg.aliases.display_name(self.source)
+        self.queue: Queue[Update] = Queue()
+        self.times = self.cfg.times.scale(self.source.samplerate)
+        self.channel_writers = tuple(
+            ChannelWriter(cfg=self.cfg, times=self.times, track=t) for t in tracks
+        )
+
+        self.input_stream = self.source.input_stream(
+            sdtype=self.cfg.sdtype,
+            update_callback=self.queue.put,
+        )
+        super().__init__(self.input_stream, *self.channel_writers)
+
+        with contextlib.suppress(KeyboardInterrupt), self:
+            while self.running:
+                with contextlib.suppress(Empty):
+                    self._receive_update(self.queue.get(timeout=POLL_TIMEOUT))
+
+        with contextlib.suppress(Empty):
+            while True:
+                self._receive_update(self.queue.get(block=False))
+
+    def _receive_update(self, u: Update) -> None:
+        if self.cfg.formats == 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)
+
+        cb = {c: c.to_block(u.array) for c in self.channel_writers}
+        should_record = self.cfg.band_mode and any(
+            c.should_record(b) for c, b in cb.items()
+        )
+        msgs = {
+            c.track.name: c.receive_update(b, u.timestamp, should_record)
+            for c, b in cb.items()
+        }
+        self.connection.send({self.source.name: msgs})
+
+        self.sample_count += len(u.array)
+        if (t := self.times.total_run_time) and self.sample_count >= t:
+            self.running = False

recs/ui/{device_tracks.py → source_tracks.py}

@@ -1,34 +1,36 @@
 import typing as t
 
 from recs.base import RecsError
-from recs.cfg import Cfg, InputDevice, Track
+from recs.cfg import Cfg, FileSource, InputDevice, Source, Track
 
-DeviceTracks = dict[InputDevice, t.Sequence[Track]]
 
+def source_tracks(cfg: Cfg) -> t.Iterator[tuple[Source, t.Sequence[Track]]]:
+    if not (cfg.devices or cfg.files):
+        raise RecsError('No inputs were found')
 
-def device_tracks(cfg: Cfg) -> DeviceTracks:
-    if not cfg.devices:
-        raise RecsError('No audio input devices were found')
+    if cfg.files:
+        for file in cfg.files:
+            source = FileSource(file)
+            channels = '1' if source.channels == 1 else f'1-{source.channels}'
+            track = Track(source, channels)
+            yield source, [track]
 
-    exc = cfg.aliases.to_tracks(cfg.exclude)
-    inc = cfg.aliases.to_tracks(cfg.include)
+    else:
+        exc = cfg.aliases.to_tracks(cfg.exclude)
+        inc = cfg.aliases.to_tracks(cfg.include)
+        for d in cfg.devices.values():
+            if tracks := list(source_track(d, exc, inc)):
+                yield d, tracks
 
-    it = ((d, list(device_track(d, exc, inc))) for d in cfg.devices.values())
-    ts: DeviceTracks = {d: v for d, v in it if v}
-    if ts:
-        return ts
 
-    raise RecsError('No channels selected')
-
-
-def device_track(
+def source_track(
     d: InputDevice, exc: t.Sequence[Track] = (), inc: t.Sequence[Track] = ()
 ) -> t.Iterator[Track]:
     if Track(d) in exc:
         return
 
-    excs = [i for i in exc if d.name == i.device.name]
-    incs = [i for i in inc if d.name == i.device.name]
+    excs = [i for i in exc if d.name == i.source.name]
+    incs = [i for i in inc if d.name == i.source.name]
     if inc and not incs:
         return
 

recs/ui/table.py

@@ -16,13 +16,13 @@ class TableFormatter:
     def __init__(self, **kwargs: t.Any):
         self.kwargs = kwargs
 
-    def _to_str(self, row, column) -> str:
+    def _to_str(self, row: t.Mapping[str, t.Any], column: str) -> str:
         _to_str = self.kwargs.get(column) or to_str
         if (x := row.get(column)) is not None:
             return _to_str(x)
         return ''
 
-    def __call__(self, rows: t.Iterator[dict[str, t.Any]]) -> Table:
+    def __call__(self, rows: t.Iterator[t.Mapping[str, t.Any]]) -> Table:
         t = Table(*self.kwargs)
         cols = set(self.kwargs)
         for r in rows:

{recs-0.3.0.dist-info → recs-0.10.0.dist-info}/METADATA

@@ -1,30 +1,31 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: recs
-Version: 0.3.0
-Summary: 🎙 recs: the Universal Recorder 🎙
-License: MIT
+Version: 0.10.0
+Summary: 🎙 The Universal Recorder 🎙
 Author: Tom Ritchford
-Author-email: tom@swirly.com
-Requires-Python: >=3.10
-Classifier: License :: OSI Approved :: MIT License
+Author-email: Tom Ritchford <tom@swirly.com>
+License-Expression: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: coverage
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: dtyper
-Requires-Dist: humanfriendly
-Requires-Dist: impall
 Requires-Dist: numpy
-Requires-Dist: overrides
 Requires-Dist: pyaudio
 Requires-Dist: rich
 Requires-Dist: sounddevice
 Requires-Dist: soundfile
+Requires-Dist: threa>=1.9.0
+Requires-Dist: typer
+Requires-Dist: impall
+Requires-Dist: overrides
+Requires-Dist: coverage
 Requires-Dist: strenum
-Requires-Dist: threa (>=1.9.0)
+Requires-Dist: humanfriendly
 Requires-Dist: tomli
-Requires-Dist: typer
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 #  🎬 recs: the Universal Recorder 🎬
@@ -138,4 +139,3 @@ detect if a  device goes offline and report it.
 The holy grail is reconnecting to a device that comes back online: this is an
 [unsolved problem](https://github.com/spatialaudio/python-sounddevice/issues/382)
 in Python, I believe, but I am on my way to solving it.
-

recs-0.10.0.dist-info/RECORD

@@ -0,0 +1,53 @@
+recs/.DS_Store,sha256=ugcyo0Wglatna4kMk2Lru97Zf5b1FcsqANtLzQdLnGk,6148
+recs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+recs/__main__.py,sha256=FjhOKF__Z0Bm-L7_DAGcG9WfhxH0A20GLI9w8oLySbY,526
+recs/audio/.DS_Store,sha256=oXSVMh_xJr9RwgcfzWnAFq7w8Bm8f7Rd2_Shw4DUe1E,6148
+recs/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+recs/audio/block.py,sha256=1EraKTLC33N0_fLjYKBnPpHAUV4L1GM08nfuGymmdxA,2644
+recs/audio/channel_writer.py,sha256=6_f3PLb5yIoFDxm3aUp_yQI9VsLtnhrhxeNHSWipy5w,7653
+recs/audio/file_opener.py,sha256=90iHmUPMfToD_OBSvpDJECub-zir6vXoxndKurkKK44,1378
+recs/audio/header_size.py,sha256=MC2PhXEjKK9KcXKc9uHLau7oFT7Qvyem5A5XSeA9a6c,412
+recs/base/.DS_Store,sha256=2dmLwn6taDy0mAi9pHfxpVnnpP33CuMp842xjRqMBOw,6148
+recs/base/__init__.py,sha256=B6x8s10ZCO9a4VrMNCzAxNdyKEhQ3YgV7d3FUgDL9PE,120
+recs/base/_query_device.py,sha256=VjsXZcdodxMAZ9iomQcEyiRKV3bjwUnXUSWd1QJ3C6Y,426
+recs/base/cfg_raw.py,sha256=QdsTu8pwu1wdxLqVDh-DfFZcozMtMT5fdr6OwrfTqsw,1429
+recs/base/prefix_dict.py,sha256=hCLvFyfgd8ZaMbN4U9RH3CwxuXng1mIycAoc3n_2JiM,640
+recs/base/pyproject.py,sha256=Qt-zH-Iy3o258UXHH3dNpw32brltE3Zs8KjVH6T20Do,379
+recs/base/state.py,sha256=ksEsiqEeUwV5KIlmg-5pcIKB_urE9DiWgQktZ9fRDws,1851
+recs/base/times.py,sha256=zyj9ufCXUBHtCLBlWsaxuN-e-QL2FRAQpVbbX2JN0dY,1013
+recs/base/type_conversions.py,sha256=YNxqbWZKzhG5d2Tp8HGjkrxNh9TlYb0IdgwB6_BU_mw,791
+recs/base/types.py,sha256=FBMXSlnjuakUONZXTTQCYXs0h-uVyajm59gDda0IJLs,814
+recs/cfg/.DS_Store,sha256=ls8VJ1hKne0S490ZI7YgG6Ppnxg4sXqpIUoXGl4ojDM,6148
+recs/cfg/__init__.py,sha256=DrXVn9QximaFakqtoKZ6o6rieRPccA2u_RBjjrE2u6s,246
+recs/cfg/aliases.py,sha256=lHIMbxGkbUCY8dIeP_a60pgrsUvFCniFrYz8gLVVLz4,2794
+recs/cfg/app.py,sha256=i2TVj9EYYQfjgYb4Ba8WEy5NAk7VPejYcjUXP_8LtfA,2246
+recs/cfg/cfg.py,sha256=yUKAT-XRc87oGzYjDFl49_8orfIwUncExYZsZPpIr0Q,3252
+recs/cfg/cli.py,sha256=cd3xD-yl06jolQKHRbGDoyvQhenuqEFqMHheaGOeLb4,7383
+recs/cfg/device.py,sha256=1SbtLWMGq7z3S52nqbujL2EymCuAX5l8ijU0EbpbP8o,2320
+recs/cfg/file_source.py,sha256=zRfQ8rSytywciFOtcxmDAE4fDDZtibNb3sIqwrFssJQ,1836
+recs/cfg/hash_cmp.py,sha256=2s2woFSx2iVotLYuzsOxz-oKUHcv0K_dWSWdv2AeZKw,456
+recs/cfg/metadata.py,sha256=m3FwKtidrm1RTmPKocwT97J2Yo6nbX-yDwzDHH2BYeE,1469
+recs/cfg/path_pattern.py,sha256=rwYXtXs7O-4J4v7HVhipi8xt8gdZZax_cEGZMjCU-N4,4413
+recs/cfg/run_cli.py,sha256=3yS74CrIrimXP4DnsAQGuOBnFTxjt8rBv2DLTJEo24s,774
+recs/cfg/source.py,sha256=iAvPksApMYgGRwEXxH-YIhr8OCknOIbqQ9srht5HQOA,1024
+recs/cfg/time_settings.py,sha256=6h0To_ypLmI2nQpU9zt7GLDcCRhcr-aE5lx0YbUFOT4,1871
+recs/cfg/track.py,sha256=clxqYKQpAvxfaUKwYPhImkiPEFUeBorggza7yLWjZtM,1908
+recs/misc/.DS_Store,sha256=v8tUVbIwzvuTCSuAPSWAv_xNN21KlXbytYjtL6lhnUU,6148
+recs/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+recs/misc/contexts.py,sha256=A9rA4ehlyAjb1n2CL7mmQVh1YLhx24yCoCu6wlAyFac,277
+recs/misc/counter.py,sha256=1BfRZ7S0XHElNO1pJtlT902niJXjGnNWlo4nNLnvtU8,1931
+recs/misc/file_list.py,sha256=R7GYzCUOdlt0QOmpne--PSoQ0E6HPZCHw0YyKdcsul8,711
+recs/misc/legal_filename.py,sha256=7FnaiI3b0S0kkfMq6AiMPWE0MbWesKtP-INJAZ0pwso,413
+recs/misc/log.py,sha256=PlYOXvp1ZB5QpLDdE79C2Ern2kl9DUYQ3p7qxPS1eUA,964
+recs/ui/.DS_Store,sha256=JO-gnxNW68i20yBD2s2Yjog-J37tclO5PYjsvpfeO4k,6148
+recs/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+recs/ui/full_state.py,sha256=TrA_TO59cSBRuMW56zs580Vkow1nbOc8sSTjYrcLtPg,2315
+recs/ui/live.py,sha256=AU-YuuNIV1Hl9wyAZhXXR_Xm8XgZmTRt9KV42vt9IKE,2665
+recs/ui/recorder.py,sha256=bkpZ8JhG8Gr-d2QrB77Pe6-Q_mWukBl-YXvRL6MOF7M,2181
+recs/ui/source_recorder.py,sha256=5axGT4zjdtsbjUla40GP32Ap9iAz0nFxk-MXWqPQybw,2490
+recs/ui/source_tracks.py,sha256=twOKAQLE6_9ERLzNRfudoROFhX5DrunY2EvE02eW3LI,2054
+recs/ui/table.py,sha256=tz7WiJVvTGhoVjUcf1kgmzeaKsCFeeZfYDMZVZ56Yik,877
+recs-0.10.0.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+recs-0.10.0.dist-info/entry_points.txt,sha256=aAL8CbBHHwb74UkJneFUiDSjLs9WayruRYao1tQXgR8,44
+recs-0.10.0.dist-info/METADATA,sha256=YBjuM_3xKsQcHsxNoz36qzKlHfa3BNP1Lzw4SfY8ZVU,4816
+recs-0.10.0.dist-info/RECORD,,

{recs-0.3.0.dist-info → recs-0.10.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: uv 0.9.28
 Root-Is-Purelib: true
 Tag: py3-none-any

recs-0.10.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+recs = recs.base.cli:run
+