midiscripter 0.2__py3-none-any.whl

midiscripter/__init__.py

@@ -0,0 +1,9 @@
+from .base.shared import restart_script, run_after_ports_opened
+from .cli import *
+from .file_event import *
+from .gui import *
+from .keyboard import *
+from .logger import *
+from .metronome import *
+from .midi import *
+from .osc import *

midiscripter/base/msg_base.py

@@ -0,0 +1,95 @@
+import enum
+from typing import Optional
+from collections.abc import Container
+
+import midiscripter.base.shared
+from midiscripter.base.port_base import Input
+
+
+class AttrEnum(enum.StrEnum):
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self.value.__repr__()})'
+
+
+class Msg:
+    """The data object generated by input port that is sent as an argument to it's registered calls
+    and can be sent with an output port."""
+
+    type: str
+    """Message type description for filtering and representation"""
+
+    ctime: float
+    """Message creation time in epoch format"""
+
+    source: Input
+    """Input port instance that generated the message."""
+
+    __match_args__: tuple[str] = ('type',)
+
+    def __init__(self, type: str, source: Input | None = None):
+        """
+        Args:
+            source: Input port instance that generated the message
+        """
+        self.type = type
+        self.source = source
+        self.ctime = midiscripter.base.shared.precise_epoch_time()
+
+        self.ctime: float  # workaround for mkdocstrings issue #607
+        """Message creation time in epoch format"""
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({", ".join(str(value) for value in self.__as_tuple())})'
+
+    def __str__(self):
+        return ' | '.join(str(value) for value in self.__as_tuple() if value is not None)
+
+    def __eq__(self, other_msg: 'Msg'):
+        return type(self) is type(other_msg) and self.__as_tuple() == other_msg.__as_tuple()
+
+    def matches(self, *args_conditions, **kwargs_conditions) -> bool:
+        """Checks if message's attributes match all provided attribute conditions:
+        1. If condition is `None` or omitted it matches anything.
+        2. If condition equals attribute it matches the attribute.
+        3. If condition is a container and contains the message attribute it matches the attribute.
+
+        Returns:
+            True if all attribute match, False if any are not
+        """
+        attr_conditions = dict(zip(self.__match_args__, args_conditions, strict=False))
+        attr_conditions.update(kwargs_conditions)
+
+        for parameter, condition in attr_conditions.items():
+            if condition is None:
+                continue
+
+            try:
+                attr = getattr(self, parameter)
+            except AttributeError:
+                continue
+
+            if attr == condition:
+                continue
+
+            if (
+                isinstance(condition, Container)
+                and not isinstance(condition, str)
+                and attr in condition
+            ):
+                continue
+
+            return False
+        return True
+
+    @property
+    def _age_ms(self) -> float:
+        """Time passed since message creation in milliseconds."""
+        return round((midiscripter.base.shared.precise_epoch_time() - self.ctime) * 1000, 3)
+
+    def __as_tuple(self) -> tuple:
+        """Converts message to a tuple based on message's __match_args__ class attribute
+
+        Returns:
+            Tuple with values of attributes specified in __match_args__ class attribute.
+        """
+        return tuple(getattr(self, attr_name) for attr_name in self.__match_args__)

midiscripter/base/port_base.py

@@ -0,0 +1,251 @@
+import collections
+import contextlib
+import copy
+import traceback
+from typing import TYPE_CHECKING, TypeVar
+from collections.abc import Callable, Hashable
+
+import midiscripter.base.shared
+from midiscripter.logger import log
+
+if TYPE_CHECKING:
+    from midiscripter.base.msg_base import Msg
+
+
+@contextlib.contextmanager
+def _all_opened():
+    for port in _PortRegistryMeta.instance_registry.values():
+        port._open()
+
+    for call in midiscripter.base.shared.run_after_ports_open_subscribed_calls:
+
+        def __call_runner():
+            try:
+                log('Running {call}', call=call)  # noqa: B023
+                call()  # noqa: B023
+            except Exception as exc:
+                log.red(''.join(traceback.format_exception(exc)))
+
+        midiscripter.base.shared.thread_executor.submit(__call_runner)
+
+    yield
+
+    for port in _PortRegistryMeta.instance_registry.values():
+        port._close()
+
+    log._flush()
+    log._sink = None
+    midiscripter.base.shared.thread_executor.shutdown(wait=True)
+
+
+class _PortRegistryMeta(type):
+    """Metaclass that enforces one uid - one port instance (singleton) rule"""
+
+    __singleton_instance_type = TypeVar('__singleton_instance_type', bound='Port')
+    """Type for correct IDE recognition and code completion for returned port subclasses"""
+
+    instance_registry: dict[tuple[str, Hashable], __singleton_instance_type] = {}
+    """Declared ports register as port class name and port uid to port instance map"""
+
+    def __call__(
+        cls: type[__singleton_instance_type], *args, **kwargs
+    ) -> __singleton_instance_type:
+        """
+        Args:
+            *args: if the class' `_force_uid` attribute is `None` (default)
+                   the metaclass uses the first argument as uid
+            **kwargs: -
+
+        Returns:
+            The singleton class instance that has requested uid
+        """
+        uid = cls._force_uid or args[0]
+
+        try:
+            return cls.instance_registry[(cls.__name__, uid)]
+        except KeyError:
+            instance = super().__call__(*args, **kwargs)
+            cls.instance_registry[(cls.__name__, uid)] = instance
+            return instance
+
+
+class Port(metaclass=_PortRegistryMeta):
+    """Port base class
+
+    Notes:
+        Port declaration with `uid` of an already existing port
+        will return the existing port (singleton)
+    """
+
+    is_enabled: bool
+    """`True` if port is listening messages / ready to send messages"""
+
+    _force_uid = None
+    """UID override for classes that have can have only one instance per whole class,
+       like keyboard port class which can have only one instance for the system.
+       Object for these classe are declared without arguments.
+    """
+
+    def __init__(self, uid: Hashable):
+        """
+        Args:
+            uid: Port's unique ID that will always lead to the same port instance
+        """
+        self._uid = uid
+        self.is_enabled = False
+
+        self.is_enabled: bool  # workaround for mkdocstrings issue #607
+        """`True` if port is listening messages / ready to send messages"""
+
+    def __repr__(self):
+        if self._force_uid:
+            return f'{self.__class__.__name__}()'
+        else:
+            return f'{self.__class__.__name__}({self._uid.__repr__()})'
+
+    def __str__(self):
+        return str(self._uid)
+
+    @property
+    def _is_available(self) -> bool:
+        """Port is available and can be opened."""
+        return True
+
+    def _open(self) -> None:
+        """Prepares and activates the port
+
+        Notes:
+            Supposed to be overridden in subclasses
+            Should have a check against second opening
+            Must set `is_enabled` parameter to `True`
+        """
+        self.is_enabled = True
+
+    def _close(self) -> None:
+        """Deactivates the port.
+
+        Notes:
+            Supposed to be overridden in subclasses
+            Must set `is_enabled` parameter to `False`
+        """
+        self.is_enabled = False
+
+
+class Input(Port):
+    """Input port base class"""
+
+    is_enabled: bool
+    """`True` if port is listening and generating messages."""
+
+    subscribed_calls: list[Callable]
+    """Callables that will be called with incoming messages. Can be modified."""
+
+    _call_statistics: dict[Callable, collections.deque[float]] = {}
+    """Statistics for each call's execution time in milliseconds for the last 20 runs."""
+
+    def __init__(self, uid: Hashable):
+        super().__init__(uid)
+        self.subscribed_calls: list[Callable] = []
+
+        self.subscribed_calls: list[Callable]  # workaround for mkdocstrings issue #607
+        """Callables that will be called with incoming messages. Can be modified."""
+
+    # A Decorator
+    def subscribe(self, function: Callable[['Msg'], None]) -> Callable:
+        """Decorator to subscribe a callable to the input's messages
+
+        ??? Example
+            ``` python
+            @input_instance.subscribe
+            def function(msg: Msg) -> None:
+                pass
+            ```
+            ``` python
+            input_instance.subscribe(object.method)
+            ```
+
+        Args:
+            function: A callable that takes the input port's message as the only argument.
+
+        Returns:
+            Subscribed callable.
+        """
+        if function not in self.subscribed_calls:
+            self._call_statistics[function] = collections.deque(maxlen=20)
+            self.subscribed_calls.append(function)
+            log('{input} subscribed {call}', input=self, call=function)
+        return function
+
+    def _send_input_msg_to_calls(self, msg: 'Msg') -> None:
+        """Sends the message received by the input port to subscribed calls.
+
+        Notes:
+            Not supposed to be overridden in subclasses.
+            Supposed to be called from the listener thread started
+            by the subclass implementation of `open` method.
+
+        Args:
+            msg: A message received by the input port to send to it's registered calls.
+        """
+        log('{input} got message {msg}', input=self, msg=msg)
+
+        if self.is_enabled:
+            # pre-copying messages to reduce jitter a little
+            msg_copies = [copy.copy(msg) for _ in range(len(self.subscribed_calls))]
+            midiscripter.base.shared.thread_executor.map(
+                self.__call_worker, self.subscribed_calls, msg_copies
+            )
+
+    def __call_worker(self, function: Callable, msg: 'Msg') -> None:
+        """Function called in thread for each subscribed call and each received message.
+
+        Notes:
+            Not supposed to be overridden in subclasses.
+            Supposed to be called from `_send_input_msg_to_calls` method.
+
+        Args:
+            function: Subscribed callable.
+            msg: Received message to use as callable only argument.
+        """
+        try:
+            function(msg)
+            self._call_statistics[function].append(msg._age_ms)
+        except TypeError:
+            function()
+            self._call_statistics[function].append(msg._age_ms)
+        except Exception as exc:
+            log.red(''.join(traceback.format_exception(exc)))
+
+
+class Output(Port):
+    """Output port base class"""
+
+    is_enabled: bool
+    """`True` if port is ready to send messages"""
+
+    def send(self, msg: 'Msg') -> None:
+        """Send message using the output port.
+
+        Args:
+            msg: Message to send.
+        """
+        with self._check_and_log_sent_message(msg):
+            raise NotImplementedError
+
+    @contextlib.contextmanager
+    def _check_and_log_sent_message(self, msg: 'Msg'):
+        if not self.is_enabled:
+            log.red("Can't send message {msg}. {output} is disabled!", msg=msg, output=self)
+            return
+
+        yield
+
+        if msg.source:
+            log(
+                '{output} sent message {msg} received {age_ms} ms ago',
+                output=self,
+                msg=msg,
+                age_ms=msg._age_ms,
+            )
+        else:
+            log('{output} sent message {msg}', output=self, msg=msg)

midiscripter/base/shared.py

@@ -0,0 +1,62 @@
+import concurrent.futures
+import os
+import platform
+import sys
+import time
+from collections.abc import Callable
+
+import __main__
+
+if platform.system() == 'Windows':
+    import win32api
+    import win32con
+    import win32process
+
+
+try:
+    script_path = __main__.__file__
+except AttributeError:  # in subprocess
+    pass
+
+
+thread_executor = concurrent.futures.ThreadPoolExecutor(100)
+
+
+_precise_time_delta = time.time() - time.perf_counter()
+
+
+def precise_epoch_time():
+    """current time in epoch format with nanosecond precision"""
+    return _precise_time_delta + time.perf_counter()
+
+
+def restart_script():
+    """Exit and restart current script"""
+    os.execv(sys.executable, ['python', script_path])
+    exit(0)
+
+
+def _raise_current_process_cpu_priority() -> None:
+    """Sets HIGH process priority in Windows for current python process"""
+    if platform.system() == 'Windows':
+        pid = win32api.GetCurrentProcessId()
+        handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
+        win32process.SetPriorityClass(handle, win32process.HIGH_PRIORITY_CLASS)
+
+
+run_after_ports_open_subscribed_calls = []
+
+
+# A Decorator
+def run_after_ports_opened(function: Callable[[], None]) -> Callable:
+    """Decorator to subscribe a callable to run after all ports are opened at the script start
+
+    Args:
+        function: A callable with no arguments
+
+    Returns:
+        Subscribed callable.
+    """
+    if function not in run_after_ports_open_subscribed_calls:
+        run_after_ports_open_subscribed_calls.append(function)
+    return function

midiscripter/cli/__init__.py

@@ -0,0 +1 @@
+from midiscripter.cli.starters import start_cli_debug, start_silent

midiscripter/cli/starters.py

@@ -0,0 +1,41 @@
+import time
+from typing import NoReturn
+
+import midiscripter.base.port_base
+import midiscripter.base.shared
+import midiscripter.logger.console_sink
+import midiscripter.logger.log
+import midiscripter.midi
+from midiscripter.logger import log
+
+
+def start_cli_debug() -> NoReturn:
+    """Starts the script with log output to console.
+    Console prints increase latency and jitter. Use for debugging only.
+    """
+    log._sink = midiscripter.logger.console_sink.ConsoleSink()
+    log('')
+    log('Available MIDI inputs:')
+    [log('{input}', input=port_name) for port_name in midiscripter.midi.MidiIn._available_names]
+    log('')
+    log('Available MIDI outputs:')
+    [log('{output}', output=port_name) for port_name in midiscripter.midi.MidiOut._available_names]
+    log('')
+    _run_cli_loop()
+
+
+def start_silent() -> NoReturn:
+    """Starts the script without logging. The fastest way to run the script."""
+    log.is_enabled = False
+    _run_cli_loop()
+
+
+def _run_cli_loop() -> NoReturn:
+    """Opens the ports and loops until broken by user."""
+    midiscripter.base.shared._raise_current_process_cpu_priority()
+    with midiscripter.base.port_base._all_opened():
+        while True:
+            try:
+                time.sleep(1)
+            except (KeyboardInterrupt, SystemExit):
+                break

midiscripter/file_event/__init__.py

@@ -0,0 +1,2 @@
+from midiscripter.file_event.file_event_msg import FileEventMsg, FileEventType
+from midiscripter.file_event.file_event_port import FileEventIn

midiscripter/file_event/file_event_msg.py

@@ -0,0 +1,49 @@
+import pathlib
+from typing import TYPE_CHECKING, Optional, Union
+
+import midiscripter.base.msg_base
+
+if TYPE_CHECKING:
+    from midiscripter.file_event.file_event_port import FileEventIn
+
+
+class FileEventType(midiscripter.base.msg_base.AttrEnum):
+    # Names are hardcoded, equal watchdog's event types
+    MOVED = 'MOVED'
+    DELETED = 'DELETED'
+    CREATED = 'CREATED'
+    MODIFIED = 'MODIFIED'
+    CLOSED = 'CLOSED'
+    OPENED = 'OPENED'
+
+
+class FileEventMsg(midiscripter.base.msg_base.Msg):
+    ___match_args__ = ('type', 'path')
+
+    type: FileEventType
+    """File event type"""
+
+    path: pathlib.Path
+    """File path of event"""
+
+    source: Optional['FileEventIn']
+
+    def __init__(
+        self,
+        type: FileEventType | str,
+        path: pathlib.Path,
+        *,
+        source: Optional['FileEventIn'] = None,
+    ):
+        """
+        Args:
+            type: File event type
+            path: File path
+            source (FileEventIn): The [`FileEventIn`][midiscripter.FileEventIn] instance that generated the message
+        """
+        super().__init__(type, source)
+        self.type = type
+        self.path = path
+
+    def matches(self, type=None, path=None):
+        return super().matches(type, path)

midiscripter/file_event/file_event_port.py

@@ -0,0 +1,76 @@
+import pathlib
+from typing import Union
+
+import watchdog.events
+import watchdog.observers
+
+import midiscripter.base.port_base
+import midiscripter.file_event
+import midiscripter.logger
+
+shared_observer = watchdog.observers.Observer()
+shared_observer.daemon = True
+shared_observer.start()
+
+
+class FileEventIn(midiscripter.base.port_base.Input, watchdog.events.FileSystemEventHandler):
+    """File system events input port. Watches file/directory modifications.
+    Produces [`FileEventMsg`][midiscripter.FileEventMsg] objects.
+    """
+
+    def __init__(self, path: str | pathlib.Path, recursive: bool = False):
+        """
+        Args:
+            path: File/directory path to watch
+            recursive: `True` to watch directory path recursively
+        """
+        if isinstance(path, str):
+            path = pathlib.Path(path)
+
+        midiscripter.base.port_base.Input.__init__(self, path)
+        watchdog.events.FileSystemEventHandler.__init__(self)
+
+        self.__path = path
+
+        if self.__path.is_dir():
+            self.__path_to_watch = self.__path
+            self.__watch_dir_changes = True
+        else:
+            self.__path_to_watch = self.__path.parent  # some editors recreate a file on save
+            self.__watch_dir_changes = False
+
+        self.__recursive = recursive
+        self.__watch = None
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}('{str(self._uid)}')"
+
+    def __str__(self):
+        return f"'{self.__path.relative_to(self.__path.parent.parent)}' watcher"
+
+    def _open(self) -> None:
+        self.__watch = shared_observer.schedule(self, str(self.__path_to_watch), self.__recursive)
+        if not shared_observer.is_alive():
+            shared_observer.start()
+        self.is_enabled = True
+        midiscripter.logger.log('Opened {input}', input=self)
+
+    def _close(self) -> None:
+        if self.__watch:
+            shared_observer.unschedule(self.__watch)
+        self.is_enabled = False
+        midiscripter.logger.log('Stopped {input}', input=self)
+
+    def on_any_event(self, event: watchdog.events.FileSystemEvent) -> None:
+        # Override of `watchdog.events.FileSystemEventHandler` method.
+        # Runs on each file system change in `_path`.
+        if not self.is_enabled:
+            return
+
+        event_path = pathlib.Path(event.src_path)
+
+        if self.__watch_dir_changes or event_path == self.__path:
+            msg = midiscripter.file_event.file_event_msg.FileEventMsg(
+                event.event_type.upper(), self.__path, source=self
+            )
+            self._send_input_msg_to_calls(msg)

midiscripter/gui/__init__.py

@@ -0,0 +1,11 @@
+from midiscripter.gui.app import add_qwidget, remove_qwidget, start_gui
+from midiscripter.gui.gui_widgets.button import (
+    GuiButton,
+    GuiButtonSelectorH,
+    GuiButtonSelectorV,
+    GuiToggleButton,
+)
+from midiscripter.gui.gui_widgets.gui_msg import GuiEventMsg, GuiEventType
+from midiscripter.gui.gui_widgets.layout import GuiWidgetLayout
+from midiscripter.gui.gui_widgets.list import GuiListSelector
+from midiscripter.gui.gui_widgets.text import GuiText