litoid 0.1.0__tar.gz

litoid-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Tom Ritchford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

litoid-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: litoid
+Version: 0.1.0
+Summary: 💡Sequence DMX lighting 💡
+License: MIT
+Author: Tom Ritchford
+Author-email: tom@swirly.com
+Requires-Python: >=3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: clsprop (>=1.1.0)
+Requires-Dist: datacls (>=4.6.0)
+Requires-Dist: distinctipy (>=1.2.2)
+Requires-Dist: dtyper (>=2.1.0)
+Requires-Dist: ipython (>=8.12.0)
+Requires-Dist: matplotlib (>=3.7.1)
+Requires-Dist: mido (>=1.2.10)
+Requires-Dist: numpy (>=1.24.2)
+Requires-Dist: psgdemos (>=1.12.1)
+Requires-Dist: pyenttec (>=1.4)
+Requires-Dist: pynput (>=1.7.6)
+Requires-Dist: pyperclip (>=1.8.2)
+Requires-Dist: pysimplegui (>=4.60.4)
+Requires-Dist: python-osc (>=1.8.1)
+Requires-Dist: python-rtmidi (>=1.5.4)
+Requires-Dist: simpleaudio (>=1.0.4)
+Requires-Dist: tomlkit (>=0.11.6)
+Requires-Dist: typer (>=0.7.0)
+Requires-Dist: xmod (>=1.4.0)
+Description-Content-Type: text/markdown
+
+# litoid
+Sequence DMX lighting
+

litoid-0.1.0/README.md

@@ -0,0 +1,2 @@
+# litoid
+Sequence DMX lighting

litoid-0.1.0/litoid/__main__.py

@@ -0,0 +1,19 @@
+def cli():
+    from . import app, litoid
+
+    assert litoid
+    app.app(standalone_mode=False)
+
+
+def gui():
+    from .ui.controller import Controller
+    import time
+
+    try:
+        Controller().start()
+    finally:
+        time.sleep(0.1)  # Allow daemon threads to print tracebacks
+
+
+if __name__ == '__main__':
+    gui()

litoid-0.1.0/litoid/app.py

@@ -0,0 +1,9 @@
+from dtyper import Argument, Option, Typer
+
+__all__ = 'Argument', 'Option', 'Typer', 'app', 'command'
+
+app = Typer(
+    add_completion=False,
+    context_settings={'help_option_names': ['-h', '--help']},
+)
+command = app.command

litoid-0.1.0/litoid/io/dmx.py

@@ -0,0 +1,19 @@
+from functools import cached_property
+import datacls
+import pyenttec
+
+
+@datacls.mutable
+class DMX:
+    port: str
+
+    @cached_property
+    def connection(self):
+        return pyenttec.DMXConnection(self.port)
+
+    @cached_property
+    def frame(self):
+        return memoryview(self.connection.dmx_frame)
+
+    def send_packet(self):
+        self.connection.render()

litoid-0.1.0/litoid/io/hotkey.py

@@ -0,0 +1,29 @@
+from ..util.has_thread import HasThread
+from functools import cached_property, partial
+from pynput import keyboard
+from typing import Callable
+import datacls
+
+
+@datacls.mutable
+class HotKeys(HasThread):
+    keys: dict[str, str] = datacls.field(dict)
+    callback: Callable = print
+
+    @cached_property
+    def hotkeys(self):
+        def cmd(k):
+            return k if '<' in k else f'<cmd>+{k}'
+
+        k = {cmd(k): partial(self.callback, v) for k, v in self.keys.items()}
+        return keyboard.GlobalHotKeys(k)
+
+    def _target(self):
+        with self.hotkeys as h:
+            h.join()
+
+
+if __name__ == '__main__':
+    s = 'abcdefghijklmnopqrstuvwxyz'
+    keys = [f'<ctrl>+{i}' for i in s]
+    HotKeys(keys)._target()

litoid-0.1.0/litoid/io/key_mouse.py

@@ -0,0 +1,26 @@
+from ..util.has_thread import HasThread
+from typing import Callable
+import datacls
+import pynput
+
+
+@datacls
+class _Base(HasThread):
+    callback: Callable = print
+
+    def _target(self):
+        with self.event_module.Events() as events:
+            for msg in events:
+                self.callback(msg)
+
+    @classmethod
+    def Message(cls) -> type:
+        return cls.event_module.Events.Event
+
+
+class Keyboard(_Base):
+    event_module = pynput.keyboard
+
+
+class Mouse(_Base):
+    event_module = pynput.mouse

litoid-0.1.0/litoid/io/midi/__init__.py

@@ -0,0 +1,3 @@
+__all__ = 'MidiInput',
+
+from . midi import MidiInput

litoid-0.1.0/litoid/io/midi/message.py

@@ -0,0 +1,219 @@
+import clsprop
+import xmod
+
+_PITCH = 0xe0
+_SYSEX = 0xF0
+
+
+@xmod
+class MidiMessage:
+    fields = ()
+    status_start = 0
+
+    __slots__ = 'data', 'time'
+
+    def __init__(self, data=None, time=0, **kwargs):
+        self.time = time
+
+        if data is not None:
+            self.data = data
+        else:
+            self.data = (
+                [self.status_start]
+                + [kwargs.pop(f, 0) or 0 for f in self.fields]
+            )
+
+        if bad := [k for k, v in kwargs.items() if v is not None]:
+            assert (data is None) or not kwargs, f'{data=} {kwargs=}'
+            s = 's' * (len(bad) != 1)
+            raise ValueError(f'Extra parameter{s}: {list(kwargs)}')
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, i):
+        return self.data[i]
+
+    @clsprop
+    def has_channel(cls) -> bool:
+        return _has_channel(cls.status_start)
+
+    @clsprop
+    def size(cls) -> int:
+        return (
+            len(cls.fields)
+            + (not cls.has_channel)
+            + (cls.status_start == _PITCH)
+        )
+
+    @property
+    def status(self):
+        return self.data[0]
+
+    def asdict(self):
+        return {k: getattr(self, k) for k in self.fields}
+
+    def __new__(cls, data=None, time=0, **kwargs):
+        if data is not None and kwargs:
+            raise ValueError('Cannot specify data and named args together')
+
+        try:
+            cls = MESSAGE_CLASSES[data[0] - 128]
+        except IndexError:
+            cls = None
+
+        if cls is None:
+            raise ValueError(f'{data=} is not a MIDI packet')
+
+        if cls.status_start != _SYSEX and len(data) != cls.size:
+            msg = f'Wrong MIDI packet length: {len(data)} != {cls.size}'
+            raise ValueError(msg)
+
+        self = super().__new__(cls)
+        cls.__init__(self, data, time, **kwargs)
+        return self
+
+
+class MidiChannelMessage(MidiMessage):
+    def __init__(self, data=None, time=0, **kwargs):
+        channel = kwargs.pop('channel', None)
+
+        if is_pitch := self.status_start == _PITCH:
+            pitch = kwargs.pop('pitch', 0)
+        super().__init__(data, time, **kwargs)
+        if is_pitch:
+            self.pitch = pitch
+        if channel is not None:
+            self.channel = channel
+
+    @property
+    def channel(self):
+        return self.status & 0x0F
+
+    @channel.setter
+    def channel(self, channel):
+        self.status = (self.status & 0xF0) | channel
+
+    def asdict(self):
+        return super().asdict() | {'channel': self.channel}
+
+
+def _has_channel(status: int) -> bool:
+    return status < _SYSEX
+
+
+def _class(status_start, name, *props):
+    if _has_channel(status_start):
+        parent = MidiChannelMessage
+        if status_start == _PITCH:
+            fields = 'pitch',
+
+        fields = 'channel', *props
+    else:
+        parent = MidiMessage
+        fields = props
+
+    members = {
+        '__init__': _init(parent, fields),
+        '__repr__': _repr(fields),
+        'fields': fields,
+        'status_start': status_start,
+    }
+
+    props = {prop: _prop(i + 1, prop) for i, prop in enumerate(props)}
+    cls = type(name, (parent,), members | _pitch(status_start) | props)
+    globals()[name] = cls
+    return cls
+
+
+def _prop(i, field):
+    def getter(self):
+        return self.data[i]
+
+    def setter(self, d):
+        self.data[i] = d
+
+    getter.__name__ = setter.__name__ = field
+    return property(getter, setter)
+
+
+def _init(parent, fields):
+    # Construct the constructor!
+    if params_in := ', '.join(f'{f}=None' for f in fields):
+        params_in = f', *, {params_in}'
+
+    if params_out := ', '.join(f'{f}={f}' for f in fields):
+        params_out = f', {params_out}'
+
+    definition = f'lambda self, data=None, time=0{params_in}:'
+    result = f'{parent.__name__}.__init__(self, data, time{params_out})'
+    init = eval(f'{definition} {result}')
+    init.__name__ = '__init__'
+    return init
+
+
+def _pitch(status_start):
+    if status_start != _PITCH:
+        return {}
+
+    pitch_offset = 0x2000
+
+    def getter(self):
+        return 0x80 * self.pitch_hsb + self.pitch_lsb - self.pitch_offset
+
+    def setter(self, p):
+        self.pitch_hsb, self.pitch_lsb = divmod(p + self.pitch_offset, 0x80)
+
+    return {
+        'pitch': property(getter, setter),
+        'pitch_offset': pitch_offset,
+    }
+
+
+def _repr(fields):
+    # See dataclasses.py around line 595
+    fields = *fields, 'time'
+    params = ', '.join(f'{f}={{self.{f}!r}}' for f in fields)
+    classname = '{self.__class__.__qualname__}'
+    rep = eval(f'lambda self: f"{classname}({params})"')
+    rep.__name__ = '__repr__'
+    return rep
+
+
+_CHANNEL = (
+    # Channel messages
+    _class(0x80, 'NoteOff', 'note', 'velocity'),
+    _class(0x90, 'NoteOn', 'note', 'velocity'),
+    _class(0xa0, 'Polytouch', 'note', 'value'),
+    _class(0xb0, 'ControlChange', 'control', 'value'),
+    _class(0xc0, 'ProgramChange', 'program'),
+    _class(0xd0, 'Aftertouch', 'value'),
+    _class(_PITCH, 'Pitch', 'pitch_lsb', 'pitch_hsb'),
+)
+
+_SYSTEM = (
+    # System common messages.
+    _class(_SYSEX, 'Sysex'),
+    _class(0xf1, 'QuarterFrame', 'frame_type', 'frame_value'),
+    _class(0xf2, 'Songpos', 'pos'),
+    _class(0xf3, 'SongSelect', 'song'),
+
+    None,  # 0xf4
+    None,  # 0xf5
+    _class(0xf6, 'TuneRequest'),
+    None,  # 0xf7 is sysex end
+
+    # System real time messages.
+    _class(0xf8, 'Clock'),
+    None,  # 0xf9
+    _class(0xfa, 'Start'),
+    _class(0xfb, 'Continue'),
+
+    _class(0xfc, 'Stop'),
+    None,  # 0xfd
+    _class(0xfe, 'ActiveSensing'),
+    _class(0xff, 'Reset'),
+)
+
+MESSAGE_CLASSES = tuple(c for c in _CHANNEL for i in range(16)) + _SYSTEM
+__all__ = ('MidiMessage',) + tuple(c.__name__ for c in _CHANNEL + _SYSTEM if c)

litoid-0.1.0/litoid/io/midi/midi.py

@@ -0,0 +1,61 @@
+from .message import MidiMessage
+from functools import cached_property
+from litoid.util.has_thread import HasThread
+from rtmidi import midiutil, MidiIn
+from typing import Callable
+import datacls
+import mido
+import time
+SPIN_TIME = 0.003
+
+
+@datacls
+class MidiOutput:
+    name: str | None = None
+
+    @cached_property
+    def output_name(self):
+        return self.name or sorted(mido.get_output_names()[0])
+
+    @cached_property
+    def output(self):
+        return mido.open_output(self.name)
+
+
+@datacls.mutable
+class MidiInput(HasThread):
+    callback: Callable = print
+    make_message: bool = True
+    name: str = ''
+    last_event_time: float = 0
+
+    def _target(self):
+        midiin, port_name = midiutil.open_midiinput(self.input_name)
+        try:
+            while True:
+                while not (msg := midiin.get_message()):
+                    time.sleep(SPIN_TIME)
+
+                mbytes, deltatime = msg
+                if self.last_event_time:
+                    self.last_event_time += deltatime
+                else:
+                    # Ignore the first deltatime, which seems to be 0 anyway
+                    self.last_event_time = time.time()
+
+                if self.make_message:
+                    msg = MidiMessage(mbytes, time=self.last_event_time)
+                self.callback(msg)
+        finally:
+            midiin.close_port()
+
+    @cached_property
+    def midiin(self):
+        return MidiIn(midiutil.get_api_from_environment())
+
+    def get_input_names(self):
+        return self.midiin.get_ports()
+
+    @cached_property
+    def input_name(self):
+        return self.name or sorted(self.get_input_names())[0]

litoid-0.1.0/litoid/io/osc.py

@@ -0,0 +1,41 @@
+from ..util.thread_queue import ThreadQueue
+from functools import cached_property
+from pythonosc.dispatcher import Dispatcher
+from pythonosc.osc_server import BlockingOSCUDPServer
+from typing import Callable
+import datacls
+
+
+@datacls.mutable
+class Desc:
+    endpoints: tuple[str] = ()
+    ip: str = '127.0.0.1'
+    port: int = 5005
+    maxsize: int = 0
+    thread_count: int = 1
+
+    def server(self):
+        return BlockingOSCUDPServer(self.ip, self.port, self.dispatcher)
+
+
+class Message(tuple):
+    pass
+
+
+@datacls.mutable
+class Server(Desc, ThreadQueue):
+    callback: Callable = print
+
+    def serve(self):
+        self.start()
+        self.desc.server().serve_forever()
+
+    @cached_property
+    def dispatcher(self):
+        d = Dispatcher()
+        for e in self.endpoints:
+            d.map(f'/{e}', self.osc_callback)
+        return d
+
+    def osc_callback(self, address, *osc_args):
+        self.put(Message(address, *osc_args))

litoid-0.1.0/litoid/io/player.py

@@ -0,0 +1,64 @@
+from .recorder import Recorder
+from .track import Track
+from functools import cached_property, total_ordering
+from litoid.util.timed_heap import TimedHeap
+from typing import Callable
+import datacls
+import time
+
+INFINITE = float('inf')
+
+
+@datacls.mutable
+class Player:
+    recorder: Recorder
+    callback: Callable = print
+    offset_time: float = 0
+    start_time: float = 0
+
+    @cached_property
+    def timed_heap(self) -> TimedHeap:
+        kt = ((k, t) for k, t in self.record.tracks.items() if t)
+        players = (TrackPlayer(self, k, t) for k, t in kt)
+        return TimedHeap([tp for tp in players if tp])
+
+    def start(self):
+        self.start_time = time.time()
+        self.timed_heap.start()
+
+    @cached_property
+    def net_offset(self) -> float:
+        return self.offset_time + self.start_time - self.recorder.start_time
+
+
+@total_ordering
+@datacls.mutable(order=False)
+class TrackPlayer:
+    player: Player
+    key: tuple[int, ...]
+    track: Track
+    position: int = 0
+
+    def __len__(self):
+        return len(self.track) - self.position
+
+    @property
+    def timestamp(self) -> float:
+        if not self:
+            return INFINITE
+        return self._timestamp() + self.player.net_offset
+
+    def __lt__(self, x) -> bool:
+        return self._timestamp() < x._timestamp()
+
+    def _timestamp(self):
+        return self.track.times[self.position]
+
+    def __call__(self):
+        msg_data = self.track.get_message(self.position)
+        self.position += 1
+
+        self.player.callback(self.key, msg_data)
+
+        if self:
+            self.player.timed_heap.push(self)

litoid-0.1.0/litoid/io/recorder.py

@@ -0,0 +1,93 @@
+from .track import Track
+from litoid import log
+from pathlib import Path
+import datacls
+import numpy as np
+import time as _time
+
+SEP = '-'
+
+
+@datacls.mutable
+class Recorder:
+    """
+    A Recorder record and timestamps messages which are sequences of bytes,
+    like MIDI or DMX.
+
+    The first one or more bytes are used as a key into a dict of Tracks,
+    and the remaining bytes are stored in a `uint8` array, and the timestamps
+    in a parallel `float64` array
+
+    This only works for protocols where you can deduce the length of the packet
+    from the initial bytes only.
+    """
+    name: str
+    path: Path | None = None
+    tracks: dict = datacls.field(dict[str, Track])
+    start_time: float = datacls.field(_time.time)
+    update_time: float = datacls.field(_time.time)
+
+    def __post_init__(self):
+        if self.path and self.path.exists():
+            self._fill_from_dict(np.load(self.path))
+            log.debug(f'Loaded {self.name}', self.report())
+
+    def record(self, data: list, key_size: int, time: float = 0):
+        time = time or _time.time()
+        key = SEP.join(str(i) for i in data[:key_size])
+
+        byte_width = len(data) - key_size
+        if (track := self.tracks.get(key)) is None:
+            track = Track(byte_width)
+            self.tracks[key] = track
+        else:
+            assert track.byte_width == byte_width
+
+        track.append(data[key_size:], time)
+        self.update_time = time
+
+        if empty := sorted(k for k, v in self.tracks.items() if not v.empty):
+            log.error('Empty tracks', *empty)
+
+    def save(self):
+        if self.path:
+            np.savez(self.path, **self.asdict())
+            log.debug(f'Saved {self.name}', self.report())
+
+    def report(self):
+        return {
+            'event_count': {k: t.count for k, t in self.tracks.items()},
+            'total_event_count': sum(t.count for t in self.tracks.values()),
+            'track_count': len(self.tracks),
+        }
+
+    def plottable(self):
+        return [i for t in self.tracks.values() for i in t.astuple()]
+
+    def asdict(self):
+        data = {'times': np.array((self.start_time, self.update_time))}
+
+        for key, track in sorted(self.tracks.items()):
+            for name, array in track.asdict().items():
+                if len(array):
+                    joined_key = SEP.join((key, name))
+                    data[joined_key] = array
+
+        return data
+
+    @classmethod
+    def fromdict(cls, d):
+        c = cls()
+        c._fill_from_dict(d)
+        return c
+
+    def _fill_from_dict(self, d):
+        parts = {}
+        for joined_key, array in d.items():
+            if joined_key == 'times':
+                self.start_time, self.update_time = array
+            else:
+                key, _, name = joined_key.rpartition(SEP)
+                parts.setdefault(key, {})[name] = array
+
+        self.tracks = {k: Track.fromdict(**v) for k, v in parts.items()}