midiscripter 0.2__tar.gz → 0.3__tar.gz

{midiscripter-0.2 → midiscripter-0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: midiscripter
-Version: 0.2
+Version: 0.3
 Summary: Framework for scripting MIDI, keyboard and Open Sound Control input and output
 Project-URL: Documentation, https://maboroshy.github.io/midi-scripter
 Project-URL: Issues, https://github.com/Maboroshy/midi-scripter/issues
@@ -175,11 +175,8 @@ License-File: LICENSE
 Keywords: MIDI,OSC,automation,input,script
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Multimedia :: Sound/Audio :: MIDI
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
@@ -191,6 +188,8 @@ Requires-Dist: python-osc~=1.7
 Requires-Dist: python-rtmidi~=1.5
 Requires-Dist: pywin32; platform_system == 'Windows'
 Requires-Dist: watchdog~=4.0
+Provides-Extra: dev
+Requires-Dist: ruff; extra == 'dev'
 Provides-Extra: doc
 Requires-Dist: griffe-inherited-docstrings; extra == 'doc'
 Requires-Dist: mkdocs-material; extra == 'doc'
@@ -199,19 +198,28 @@ Description-Content-Type: text/markdown
 
 # MIDI Scripter
 
-MIDI Scripter is a framework for scripting MIDI, keyboard and Open Sound Control (OSC) input and output with a few lines of Python code.
+MIDI Scripter is a framework for scripting MIDI, keyboard and Open Sound
+Control (OSC) input and output with only a few lines of Python code.
 
-MIDI Scripter is intended for digital audio workstation (DAW) controls scripting but can also be used for general input conversion and automation. It fits where controller mappings are not enough but rewriting DAW controller integration is too much. 
+MIDI Scripter listens to selected input ports and feed incoming messages to
+subscribed callables (functions, methods, etc.). These callables or any
+other Python code can send modified or brand-new messages with
+output ports. MIDI Scripter can act as a proxy to filter and transform and
+convert the input.
+
+MIDI Scripter included customizable GUI that provides messages logging,
+"ready to paste" port and message declarations and one line of code widgets for
+monitoring / controlling scripts.
 
 An octave transposer with GUI controls in 10 lines of code:
 
 ``` python
-from midiscripter import *  # safe * import with no bloat
+from midiscripter import *
 
-midi_keyboard = MidiIn('Port name')  # GUI will provide you with port names
-proxy_output = MidiOut('loopMIDI Port') # using loopMIDI virtual port for output
+midi_keyboard = MidiIn('MIDI Keyboard')  # GUI will provide you with port names
+proxy_output = MidiOut('To DAW')  # using virtual port for output
 
-# GUI control in a single line, many widget available, custom widgets supported
+# GUI control in a single line
 octave_selector = GuiButtonSelectorH(('-2', '-1', '0', '+1', '+2'), select='0')
 
 @midi_keyboard.subscribe  # decorated function will receive port's messages
@@ -224,39 +232,70 @@ if __name__ == '__main__':  # combine multiple scripts by importing them
 	start_gui()  # opens helpful customizable GUI
 ```
 
-![Screenshot](https://github.com/Maboroshy/midi-scripter/blob/master/examples/octave_transposer/screenshot.png?raw=true)
+![Screenshot after some widget arrangement](https://github.com/Maboroshy/midi-scripter/blob/master/examples/octave_transposer/screenshot.png?raw=true)
+
+[You can find more examples here.](https://github.com/Maboroshy/midi-scripter/tree/master/examples)
+
+[Scripting guide and API documentation available.](https://maboroshy.github.io/midi-scripter)
+
+Currently MIDI Scripter is at "beta" development stage. It's fully
+functional but needs more user feedback. It works on Windows and Linx and
+should work on macOS.
+
+## What it can do
+
+For writing Python code:
 
-[Scripting guide and API documentation available](https://maboroshy.github.io/midi-scripter)
+- Prepare MIDI, OSC and keyboard inputs and outputs with a single line,
+  without boilerplate code.
+- Feed input messages to functions or any callables by "decorating" them.
+- Work with common message objects instead of raw data different for each port
+  type.
+- Send MIDI, OSC and keyboard output messages.
+- Create GUI widgets with one line and arrange them with mouse on your script's
+  dashboard.
 
-Easy tasks for MIDI Scripter:  
-1. Filter, modify and route MIDI, OSC and keyboard messages in any way.  
-2. Map MIDI, OSC and keyboard to each other.  
-3. Map any Python code to input message.  
-4. Make extra "shift" keys to multiply MIDI controls.  
-5. Organize mappings into sets / scenes with GUI controls.  
-6. Make an extra overlay mappings on top of MIDI controller's default DAW integration by using proxy.  
+For live performance setups:
 
-Complex tasks for MIDI Scripter:
-1. Create and map complex macros involving multiple hardware or virtual MIDI controllers.
-2. Make custom sequencer or MIDI input generator.
-3. Make music education ot trainer GUI application based on MIDI input.
+- Make extra layers to multiply MIDI controls.
+- Organize mappings into sets / scenes with GUI dashboard.
+- Make an extra overlay mappings on top of MIDI controller's DAW integration by
+  using proxies.
+- Create and map complex macros.
 
-Currently MIDI Scripter is at "beta" development stage. It's fully functional but needs some more testing. It targets only Windows for now but Linux and macOS support will follow.
+For MIDI related apps:
+
+- Make custom sequencers or MIDI output generators.
+- Make basic music training GUI applications based on MIDI input.
+
+For software control and automation:
+
+- Use MIDI controllers or keyboard shortcuts to run any Python code.
+- Use keyboard macros to control apps.
 
 ## Installation
-1. [Python 3.11+](https://www.python.org/downloads/) with "Add python.exe to PATH" option.
-2. [loopMIDI](https://www.tobias-erichsen.de/software/loopmidi.html) for virtual MIDI output ports on Windows.
-3. `pip install midiscripter` in console.
 
-## Setup
-Run loopMIDI and add virtual ports you want to send MIDI messages. You can enable its autostart option.
+1. Install [Python 3.11+](https://www.python.org/downloads/) including pip.
+2. Run `pip install midiscripter`.
 
-Enable virtual MIDI output ports as MIDI inputs in DAW. 
+Extra steps for Windows:
+
+1. Enable `Add python .exe to PATH` option in Python installer.
+2. Install [loopMIDI](https://www.tobias-erichsen.de/software/loopmidi.html)
+   and set required virtual MIDI ports inside it.
 
 ## Quick Start
-1. Paste [script template](examples/script_template.py) to Python IDE or plain text editor. IDE is greatly recommended.
-2. Run unchanged template script from IDE or by `python .\script_template.py` to open GUI for more info on available ports and their input.
-3. Turn on the ports' checkboxes to enable them and watch the log for input messages.
-4. Click on port names and messages to copy their declarations to the clipboard. Paste the declarations to your script.
-5. Write the functions you need. Subscribe them to messages with `@input_port.subscribe` decorator. Use `log('messages')` for debugging. Use `output_port.send(msg)` to send modified or created messages from a function.
-6. Restart the script from GUI.
+
+1. Paste [script template](examples/script_template.py) to Python IDE or plain
+   text editor. IDE is greatly recommended.
+2. Run unaltered template script from IDE or by `python` command to open GUI for
+   more info on available ports and their input.
+3. Turn on available ports' checkboxes to enable them, and watch the log for
+   input messages.
+4. Click on port names and messages to copy their declarations to the clipboard.
+   Paste the declarations to your script.
+5. Write the functions you need. Subscribe them to input messages with
+   `@input_port.subscribe` decorator. Use `log('messages')` for debugging.
+   Use `output_port.send(msg)` to send modified or created messages from a
+   function.
+6. Restart the script from GUI to check how in works.

midiscripter-0.3/README.md

@@ -0,0 +1,103 @@
+# MIDI Scripter
+
+MIDI Scripter is a framework for scripting MIDI, keyboard and Open Sound
+Control (OSC) input and output with only a few lines of Python code.
+
+MIDI Scripter listens to selected input ports and feed incoming messages to
+subscribed callables (functions, methods, etc.). These callables or any
+other Python code can send modified or brand-new messages with
+output ports. MIDI Scripter can act as a proxy to filter and transform and
+convert the input.
+
+MIDI Scripter included customizable GUI that provides messages logging,
+"ready to paste" port and message declarations and one line of code widgets for
+monitoring / controlling scripts.
+
+An octave transposer with GUI controls in 10 lines of code:
+
+``` python
+from midiscripter import *
+
+midi_keyboard = MidiIn('MIDI Keyboard')  # GUI will provide you with port names
+proxy_output = MidiOut('To DAW')  # using virtual port for output
+
+# GUI control in a single line
+octave_selector = GuiButtonSelectorH(('-2', '-1', '0', '+1', '+2'), select='0')
+
+@midi_keyboard.subscribe  # decorated function will receive port's messages
+def transpose(msg: MidiMsg) -> None:
+	if msg.type == MidiType.NOTE_ON or msg.type == MidiType.NOTE_OFF:  # filter
+		msg.data1 += 12 * int(octave_selector.selected_item_text)  # modify
+		proxy_output.send(msg)  # route
+
+if __name__ == '__main__':  # combine multiple scripts by importing them
+	start_gui()  # opens helpful customizable GUI
+```
+
+![Screenshot after some widget arrangement](https://github.com/Maboroshy/midi-scripter/blob/master/examples/octave_transposer/screenshot.png?raw=true)
+
+[You can find more examples here.](https://github.com/Maboroshy/midi-scripter/tree/master/examples)
+
+[Scripting guide and API documentation available.](https://maboroshy.github.io/midi-scripter)
+
+Currently MIDI Scripter is at "beta" development stage. It's fully
+functional but needs more user feedback. It works on Windows and Linx and
+should work on macOS.
+
+## What it can do
+
+For writing Python code:
+
+- Prepare MIDI, OSC and keyboard inputs and outputs with a single line,
+  without boilerplate code.
+- Feed input messages to functions or any callables by "decorating" them.
+- Work with common message objects instead of raw data different for each port
+  type.
+- Send MIDI, OSC and keyboard output messages.
+- Create GUI widgets with one line and arrange them with mouse on your script's
+  dashboard.
+
+For live performance setups:
+
+- Make extra layers to multiply MIDI controls.
+- Organize mappings into sets / scenes with GUI dashboard.
+- Make an extra overlay mappings on top of MIDI controller's DAW integration by
+  using proxies.
+- Create and map complex macros.
+
+For MIDI related apps:
+
+- Make custom sequencers or MIDI output generators.
+- Make basic music training GUI applications based on MIDI input.
+
+For software control and automation:
+
+- Use MIDI controllers or keyboard shortcuts to run any Python code.
+- Use keyboard macros to control apps.
+
+## Installation
+
+1. Install [Python 3.11+](https://www.python.org/downloads/) including pip.
+2. Run `pip install midiscripter`.
+
+Extra steps for Windows:
+
+1. Enable `Add python .exe to PATH` option in Python installer.
+2. Install [loopMIDI](https://www.tobias-erichsen.de/software/loopmidi.html)
+   and set required virtual MIDI ports inside it.
+
+## Quick Start
+
+1. Paste [script template](examples/script_template.py) to Python IDE or plain
+   text editor. IDE is greatly recommended.
+2. Run unaltered template script from IDE or by `python` command to open GUI for
+   more info on available ports and their input.
+3. Turn on available ports' checkboxes to enable them, and watch the log for
+   input messages.
+4. Click on port names and messages to copy their declarations to the clipboard.
+   Paste the declarations to your script.
+5. Write the functions you need. Subscribe them to input messages with
+   `@input_port.subscribe` decorator. Use `log('messages')` for debugging.
+   Use `output_port.send(msg)` to send modified or created messages from a
+   function.
+6. Restart the script from GUI to check how in works.

{midiscripter-0.2 → midiscripter-0.3}/midiscripter/base/msg_base.py

@@ -1,5 +1,4 @@
 import enum
-from typing import Optional
 from collections.abc import Container
 
 import midiscripter.base.shared

{midiscripter-0.2 → midiscripter-0.3}/midiscripter/base/port_base.py

@@ -2,8 +2,8 @@ import collections
 import contextlib
 import copy
 import traceback
-from typing import TYPE_CHECKING, TypeVar
 from collections.abc import Callable, Hashable
+from typing import TYPE_CHECKING, TypeVar
 
 import midiscripter.base.shared
 from midiscripter.logger import log
@@ -13,13 +13,13 @@ if TYPE_CHECKING:
 
 
 @contextlib.contextmanager
-def _all_opened():
+def _all_opened() -> None:
     for port in _PortRegistryMeta.instance_registry.values():
         port._open()
 
     for call in midiscripter.base.shared.run_after_ports_open_subscribed_calls:
 
-        def __call_runner():
+        def __call_runner() -> None:
             try:
                 log('Running {call}', call=call)  # noqa: B023
                 call()  # noqa: B023
@@ -229,17 +229,21 @@ class Output(Port):
         Args:
             msg: Message to send.
         """
-        with self._check_and_log_sent_message(msg):
-            raise NotImplementedError
+        if not self._validate_msg_send(msg):
+            return
+
+        raise NotImplementedError
 
-    @contextlib.contextmanager
-    def _check_and_log_sent_message(self, msg: 'Msg'):
+        # noinspection PyUnreachableCode
+        self._log_msg_sent(msg)
+
+    def _validate_msg_send(self, msg: 'Msg') -> bool:
         if not self.is_enabled:
             log.red("Can't send message {msg}. {output} is disabled!", msg=msg, output=self)
-            return
-
-        yield
+            return False
+        return True
 
+    def _log_msg_sent(self, msg: 'Msg') -> None:
         if msg.source:
             log(
                 '{output} sent message {msg} received {age_ms} ms ago',

midiscripter-0.3/midiscripter/base/shared.py

@@ -0,0 +1,140 @@
+import concurrent.futures
+import os
+import pathlib
+import platform
+import plistlib
+import sys
+import time
+from collections.abc import Callable
+
+import __main__
+
+if platform.system() == 'Windows':
+    import win32api
+    import win32con
+    import win32process
+    import win32com.client
+
+
+try:
+    script_path = __main__.__file__
+except AttributeError:  # in subprocess or IPython
+    script_path = None
+
+
+thread_executor = concurrent.futures.ThreadPoolExecutor(100)
+
+
+_precise_time_delta = time.time() - time.perf_counter()
+
+
+def precise_epoch_time() -> float:
+    """current time in epoch format with nanosecond precision"""
+    return _precise_time_delta + time.perf_counter()
+
+
+def restart_script() -> None:
+    """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
+
+
+class AutostartManager:
+    def __init__(self):
+        self.__autostart_shortcut_prefix = 'MIDI Scripter - '
+        self.__script_path = pathlib.Path(script_path).resolve()
+        self.__shortcut_name = f'{self.__autostart_shortcut_prefix}{self.__script_path.stem}'
+
+        if platform.system() == 'Windows':
+            self.__autostart_dir_path = (
+                pathlib.Path.home()
+                / 'AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup'
+            )
+            __shortcut_extension = 'lnk'
+        elif platform.system() == 'Linux' or platform.system() == 'Darwin':
+            self.__autostart_dir_path = pathlib.Path.home() / '.config/autostart'
+            __shortcut_extension = 'desktop'
+        elif platform.system() == 'Darwin':
+            self.__autostart_dir_path = pathlib.Path.home() / 'Library/LaunchAgents'
+            __shortcut_extension = 'plist'
+
+        self.__autostart_shortcut_path = (
+            self.__autostart_dir_path / f'{self.__shortcut_name}.{__shortcut_extension}'
+        )
+
+    def _check_if_enabled(self) -> bool:
+        return self.__autostart_shortcut_path.is_file()
+
+    def __other_scripts_shortcuts(self) -> list[pathlib.Path]:
+        return [
+            path
+            for path in self.__autostart_dir_path.iterdir()
+            if (
+                path.name.startswith(self.__autostart_shortcut_prefix)
+                and path.is_file()
+                and path != self.__autostart_shortcut_path.resolve()
+            )
+        ]
+
+    def _check_if_other_scripts_present(self) -> bool:
+        return bool(self.__other_scripts_shortcuts())
+
+    def _enable(self) -> None:
+        if platform.system() == 'Windows':
+            shell = win32com.client.Dispatch('WScript.Shell')
+            shortcut = shell.CreateShortCut(str(self.__autostart_shortcut_path.resolve()))
+            shortcut.Targetpath = str(pathlib.Path(sys.executable).parent / 'pythonw.exe')
+            shortcut.WorkingDirectory = str(self.__script_path.parent.resolve())
+            shortcut.Arguments = f'"{self.__script_path}" "--tray"'
+            shortcut.save()
+
+        elif platform.system() == 'Linux':
+            desktop_file_content = (
+                '[Desktop Entry]\n'
+                f'Name={self.__shortcut_name}\n'
+                f'Exec=python "{self.__script_path}" --tray\n'
+                'Type=Application\n'
+                'Terminal=false\n'
+            )
+            self.__autostart_shortcut_path.write_text(desktop_file_content)
+
+        elif platform.system() == 'Darwin':  # Not tested, help needed
+            plist_file_content = {
+                'Label': self.__shortcut_name,
+                'RunAtLoad': True,
+                'ProgramArguments': [sys.executable, str(self.__script_path), '--tray'],
+            }
+            self.__autostart_shortcut_path.write_bytes(plistlib.dumps(plist_file_content))
+
+    def _disable(self) -> None:
+        self.__autostart_shortcut_path.unlink(missing_ok=True)
+
+    def _disable_others(self) -> None:
+        for path in self.__other_scripts_shortcuts():
+            path.unlink()

{midiscripter-0.2 → midiscripter-0.3}/midiscripter/cli/starters.py

@@ -32,6 +32,9 @@ def start_silent() -> NoReturn:
 
 def _run_cli_loop() -> NoReturn:
     """Opens the ports and loops until broken by user."""
+    if not midiscripter.base.shared.script_path:
+        raise RuntimeError('Starter can only be called from a script')
+
     midiscripter.base.shared._raise_current_process_cpu_priority()
     with midiscripter.base.port_base._all_opened():
         while True:

{midiscripter-0.2 → midiscripter-0.3}/midiscripter/file_event/file_event_msg.py

@@ -1,9 +1,10 @@
 import pathlib
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 import midiscripter.base.msg_base
 
 if TYPE_CHECKING:
+    from collections.abc import Container
     from midiscripter.file_event.file_event_port import FileEventIn
 
 
@@ -26,24 +27,29 @@ class FileEventMsg(midiscripter.base.msg_base.Msg):
     path: pathlib.Path
     """File path of event"""
 
-    source: Optional['FileEventIn']
+    source: 'None | FileEventIn'
 
     def __init__(
         self,
         type: FileEventType | str,
         path: pathlib.Path,
         *,
-        source: Optional['FileEventIn'] = None,
+        source: 'None | FileEventIn' = None,
     ):
         """
         Args:
             type: File event type
             path: File path
-            source (FileEventIn): The [`FileEventIn`][midiscripter.FileEventIn] instance that generated the message
+            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):
+    def matches(
+        self,
+        type: 'None | Container[FileEventType] | FileEventType | str' = None,
+        path: 'None | Container[pathlib.Path] | pathlib.Path' = None,
+    ) -> bool:
         return super().matches(type, path)

{midiscripter-0.2 → midiscripter-0.3}/midiscripter/file_event/file_event_port.py

@@ -1,5 +1,4 @@
 import pathlib
-from typing import Union
 
 import watchdog.events
 import watchdog.observers

{midiscripter-0.2 → midiscripter-0.3}/midiscripter/gui/app.py

@@ -25,7 +25,9 @@ class ScripterGUI(QApplication):
     def __init__(self):
         super().__init__()
         self.setOrganizationName('MIDI Scripter')
-        self.setApplicationName(pathlib.Path(midiscripter.base.shared.script_path).name)
+        if midiscripter.base.shared.script_path:
+            self.setApplicationName(pathlib.Path(midiscripter.base.shared.script_path).name)
+
         icon_path = pathlib.Path(midiscripter.__file__).parent / 'resources' / 'icon.ico'
         self.setWindowIcon(QIcon(str(icon_path)))
 
@@ -33,7 +35,7 @@ class ScripterGUI(QApplication):
         self.request_restart.connect(self, self.restart)
         self.aboutToQuit.connect(self.__cleanup)
 
-    def prepare_main_window(self, minimized_to_tray: bool = False):
+    def prepare_main_window(self, minimized_to_tray: bool = False) -> None:
         self.main_window = midiscripter.gui.main_window.MainWindow(self.widgets_to_add)
 
         if not minimized_to_tray:
@@ -41,7 +43,9 @@ class ScripterGUI(QApplication):
         else:
             self.main_window.close()
 
-    def restart_at_file_change(self, msg: 'midiscripter.file_event.file_change_msg.FileEventMsg'):
+    def restart_at_file_change(
+        self, msg: 'midiscripter.file_event.file_change_msg.FileEventMsg'
+    ) -> None:
         if msg.type not in (
             midiscripter.file_event.file_event_msg.FileEventType.CREATED,
             midiscripter.file_event.file_event_msg.FileEventType.MODIFIED,
@@ -57,15 +61,15 @@ class ScripterGUI(QApplication):
 
         self.request_restart.emit()
 
-    def restart(self):
+    def restart(self) -> NoReturn:
         if pathlib.Path(midiscripter.base.shared.script_path).is_file():
             # These settings saved only for restart
             self.processEvents()  # update win status to get correct status
-            QSettings().setValue('restart win minimized', int(self.main_window.isMinimized()))
-            QSettings().setValue('restart closed to tray', int(not self.main_window.isVisible()))
+            QSettings().setValue('restart win minimized', self.main_window.isMinimized())
+            QSettings().setValue('restart closed to tray', not self.main_window.isVisible())
             self.exit(1467)
 
-    def __cleanup(self):
+    def __cleanup(self) -> None:
         self.main_window.close()
         self.main_window.tray.hide()
 
@@ -74,13 +78,13 @@ class ScripterGUI(QApplication):
 app_instance = ScripterGUI()
 
 
-def add_qwidget(qwidget: QWidget):
+def add_qwidget(qwidget: QWidget) -> None:
     """Add custom pyside6 QWidget to the GUI"""
     if qwidget not in midiscripter.gui.app.ScripterGUI.widgets_to_add:
         midiscripter.gui.app.ScripterGUI.widgets_to_add.append(qwidget)
 
 
-def remove_qwidget(qwidget: QWidget):
+def remove_qwidget(qwidget: QWidget) -> None:
     """Remove custom pyside6 QWidget to the GUI"""
     try:
         midiscripter.gui.app.ScripterGUI.widgets_to_add.remove(qwidget)
@@ -89,6 +93,9 @@ def remove_qwidget(qwidget: QWidget):
 
 
 def start_gui() -> NoReturn:
+    if not midiscripter.base.shared.script_path:
+        raise RuntimeError('Starter can only be called from a script')
+
     """Starts the script and runs GUI. Logging goes to GUI Log widget."""
     midiscripter.base.shared._raise_current_process_cpu_priority()
 

{midiscripter-0.2 → midiscripter-0.3}/midiscripter/gui/gui_widgets/button.py

@@ -1,4 +1,3 @@
-from typing import Optional, Union
 from collections.abc import Sequence
 
 from PySide6.QtWidgets import *
@@ -113,7 +112,7 @@ class ButtonGroupWidgetHorizontal(WrappedQWidgetMixin, QWidget):
 
         self.qt_button_group.idReleased.connect(self.selection_changed_signal)
 
-    def set_selection(self, selection: int | str):
+    def set_selection(self, selection: int | str) -> None:
         try:
             self.wrapped_qt_buttons_map[selection].click()
         except KeyError:
@@ -134,7 +133,7 @@ class GuiButtonSelectorH(GuiWidget):
 
     def __init__(
         self,
-        content: Sequence[str],
+        content: tuple[str, ...],
         title: str | None = None,
         color: str | tuple[int, int, int] | None = None,
         *,
@@ -161,7 +160,7 @@ class GuiButtonSelectorV(GuiWidget):
 
     def __init__(
         self,
-        content: Sequence[str],
+        content: tuple[str, ...],
         title: str | None = None,
         color: str | tuple[int, int, int] | None = None,
         *,