IS-Matrix-Forge 1.0.0.dev1__py3-none-any.whl

is_matrix_forge/led_matrix/controller/multiton.py

@@ -0,0 +1,32 @@
+from typing import Any, Dict, Type
+
+class MultitonMeta(type):
+    """
+    Metaclass that ensures only one instance per “key” exists.
+    By default, it uses the first positional argument (your `device`)
+    and looks up its `.device` attribute (if present) or `repr()` as the unique key.
+    """
+    def __init__(cls, name, bases, attrs):
+        super().__init__(name, bases, attrs)
+        # per–subclass registry
+        cls._instances: Dict[Any, cls] = {}
+        # allow subclasses to override which attr to use on device
+        cls.MULTITON_KEY_ATTR: str = attrs.get('MULTITON_KEY_ATTR', 'device')
+
+    def __call__(cls, *args, **kwargs):
+        # pull out the “device” argument
+        if cls.MULTITON_KEY_ATTR in kwargs:
+            dev = kwargs[cls.MULTITON_KEY_ATTR]
+        elif args:
+            dev = args[0]
+        else:
+            raise TypeError(f"Missing '{cls.MULTITON_KEY_ATTR}' argument")
+        # pick a raw key from either dev.<attr> or repr(dev)
+        raw_key = getattr(dev, cls.MULTITON_KEY_ATTR, repr(dev))
+        # return existing if we've already built one
+        if raw_key in cls._instances:
+            return cls._instances[raw_key]
+        # otherwise build & cache a new one
+        inst = super().__call__(*args, **kwargs)
+        cls._instances[raw_key] = inst
+        return inst

is_matrix_forge/led_matrix/controller/threaded.py

@@ -0,0 +1,72 @@
+import threading
+import queue
+from typing import Optional, Any
+
+class ThreadedLEDMatrixController:
+    """
+    Wraps an LEDMatrixController to execute commands in one or more background threads,
+    ensuring no calls are lost when invoked concurrently.
+
+    Usage:
+        base = LEDMatrixController(device, default_brightness=50)
+        threaded = ThreadedLEDMatrixController(base, max_queue_size=100, num_workers=2)
+        # now you can spam commands from any thread, and they’ll all run:
+        threaded.draw_grid(grid1)
+        threaded.set_brightness(80)
+        threaded.animate(True)
+        # ...even while a long identify() or Breather is running!
+
+    Parameters:
+        controller (LEDMatrixController):
+            The controller to wrap.
+
+        max_queue_size (int, optional):
+            Maximum number of queued commands. Defaults to infinite.
+
+        num_workers (int, optional):
+            Number of worker threads processing the queue. Defaults to 1.
+    """
+
+    def __init__(
+        self,
+        controller: Any,
+        max_queue_size: Optional[int] = None,
+        num_workers: int = 1
+    ):
+        self._controller = controller
+        # infinite size if you don't care about spam limits
+        self._queue = queue.Queue(maxsize=max_queue_size) if max_queue_size else queue.Queue()
+        self._workers = []
+        for i in range(max(1, num_workers)):
+            t = threading.Thread(target=self._worker, daemon=True, name=f"LEDWorker-{i}")
+            t.start()
+            self._workers.append(t)
+
+    def _worker(self):
+        while True:
+            method_name, args, kwargs = self._queue.get()
+            try:
+                getattr(self._controller, method_name)(*args, **kwargs)
+            except Exception as e:
+                # feel free to hook up your own logger here
+                print(f"[ThreadedLEDMatrixController] Error in {method_name}: {e}")
+            finally:
+                self._queue.task_done()
+
+    def enqueue(self, method_name: str, /, *args, **kwargs):
+        """
+        Enqueue a method call by name. Raises queue.Full if the queue is full.
+        """
+        self._queue.put((method_name, args, kwargs))
+
+    def __getattr__(self, name: str):
+        """
+        Proxy any attribute to the wrapped controller.
+        If it’s a callable, return a wrapper that enqueues the call.
+        """
+        attr = getattr(self._controller, name)
+        if callable(attr):
+            def wrapper(*args, **kwargs):
+                self.enqueue(name, *args, **kwargs)
+            return wrapper
+        return attr

is_matrix_forge/led_matrix/display/__init__.py

@@ -0,0 +1,13 @@
+"""
+Display module for LED Matrix.
+
+This module provides functions for displaying various content on the LED matrix,
+including patterns, text, and media.
+"""
+
+# Import and re-export all display-related functions
+from .patterns.built_in.stencils import checkerboard
+from .helpers import light_leds
+from .helpers.columns import send_col, commit_cols
+from .text import show_string, show_font, show_symbols
+from .media import image, image_greyscale, camera, video, pixel_to_brightness

is_matrix_forge/led_matrix/display/animations/__init__.py

@@ -0,0 +1,29 @@
+from time import sleep
+
+
+from is_matrix_forge.led_matrix.hardware import brightness
+from is_matrix_forge.led_matrix.display.text import show_string
+
+
+def clear(dev):
+    brightness(dev, 0)
+
+
+def checkerboard_cycle(dev):
+    from is_matrix_forge.led_matrix.display.patterns.built_in.stencils import checkerboard
+    frame = 2
+
+    while frame < 5:
+        brightness(dev, 25)
+        print(f'Processing frame: {frame}')
+        sleep(1)
+        checkerboard(dev, frame)
+        frame += 1
+
+
+def goodbye_animation(dev):
+    clear(dev)
+    sleep(.1)
+    checkerboard_cycle(dev)
+    sleep(.5)
+    show_string(dev, 'Bye')