IS-Matrix-Forge 1.0.0.dev2__py3-none-any.whl → 1.0.0.dev5__py3-none-any.whl

is_matrix_forge/__init__.py

@@ -3,6 +3,6 @@ Author: Taylor B. tayjaybabee@gmail.com
 Date: 2025-04-15 09:15:25
 LastEditors: Taylor B. tayjaybabee@gmail.com
 LastEditTime: 2025-04-15 09:24:40
-FilePath: is_matrix_forge/__init__.py
+FilePath: is_matrix_forge/grid.py
 Description: 这是默认设置,可以在设置》工具》File Description中进行配置
 """

is_matrix_forge/assets/__init__.py

@@ -3,6 +3,6 @@ Author: Taylor B. tayjaybabee@gmail.com
 Date: 2025-04-15 09:15:37
 LastEditors: Taylor B. tayjaybabee@gmail.com
 LastEditTime: 2025-04-15 09:24:40
-FilePath: is_matrix_forge/assets/__init__.py
+FilePath: is_matrix_forge/assets/grid.py
 Description: 这是默认设置,可以在设置》工具》File Description中进行配置
 """

is_matrix_forge/common/helpers/__init__.py

@@ -3,6 +3,10 @@ from pathlib import Path
 from typing import Optional
 import requests
 from inspyre_toolbox.path_man import provision_path
+from is_matrix_forge.log_engine import ROOT_LOGGER
+
+
+MOD_LOGGER = ROOT_LOGGER.get_child(__name__)
 
 
 def download_presets():
@@ -24,9 +28,13 @@ def calculate_checksum(file_path):
         str:
             The SHA-256 checksum of the file.
     """
+    log = MOD_LOGGER.get_child('calculate_checksum')
+
     if not isinstance(file_path, Path):
         file_path = provision_path(file_path)
 
+    log.debug(f'Calculating checksum for file: {file_path}')
+
     sha256 = hashlib.sha256()
 
     with open(file_path, 'rb') as f:
@@ -78,6 +86,30 @@ def percentage_to_value(percent, max_value=255):
     return int(round(percent * max_value / 100))
 
 
+def value_to_percentage(value, max_value=255):
+    """
+    Convert a value to its percentage representation relative to `max_value`.
+
+    Parameters:
+        value (int or float):
+            The value to convert.
+
+        max_value (int, optional):
+            The maximum possible value. Defaults to 255.
+
+    Returns:
+        float:
+            The percentage value between 0 and 100.
+    """
+    if not isinstance(value, (int, float)):
+        raise TypeError(f'value must be of type int or float, not {type(value)}')
+
+    if value < 0 or value > max_value:
+        raise ValueError(f'value must be between 0 and {max_value}, not {value}')
+
+    return (value / max_value) * 100
+
+
 def verify_checksum(remote_checksum, local_file_path):
     """
     Verify the checksum of a local file against a remote checksum.

is_matrix_forge/designer_gui/__init__.py

@@ -3,6 +3,6 @@ Author: Taylor B. tayjaybabee@gmail.com
 Date: 2025-04-30 16:01:10
 LastEditors: Taylor B. tayjaybabee@gmail.com
 LastEditTime: 2025-04-30 16:01:49
-FilePath: is_matrix_forge/designer_gui/__init__.py
+FilePath: is_matrix_forge/designer_gui/grid.py
 Description: 这是默认设置,可以在设置》工具》File Description中进行配置
 """

is_matrix_forge/designer_gui/main_window/__init__.py

@@ -4,12 +4,15 @@ import PySimpleGUI as sg
 import copy
 import os
 
-from ...led_matrix.helpers.device import DEVICES
+from is_matrix_forge.led_matrix.helpers.device import DEVICES
 from is_matrix_forge.led_matrix.display.animations.frame.base import Frame
 from is_matrix_forge.led_matrix.display.grid.helpers import is_valid_grid
 from is_matrix_forge.led_matrix.display.animations.frame.helpers import is_valid_frames
-from .layout import PixelGridLayout
-from is_matrix_forge.led_matrix import render_matrix
+from is_matrix_forge.designer_gui.main_window.layout import PixelGridLayout
+from is_matrix_forge.led_matrix.display.helpers import render_matrix
+
+
+sg.theme('DarkTeal2')
 
 
 def _normalize(key: Any) -> str:
@@ -139,6 +142,7 @@ class PixelGrid:
     def _toggle_pixel(self, key: Tuple[int, int]) -> None:
         col, row = key
         new = 1 - self.grid[col][row]
+        print(f'Pixel {col},{row} toggled from {self.grid[col][row]} to {new}')
         self.grid = [[new if (c==col and r==row) else self.grid[c][r]
                       for r in range(self.height)]
                      for c in range(self.width)]
@@ -250,3 +254,7 @@ class PixelGrid:
 
     def _validate(self, grid: Any) -> bool:
         return is_valid_grid(grid, self.width, self.height)
+
+
+if __name__ == '__main__':
+    PixelGrid().run()

is_matrix_forge/designer_gui/main_window/{layout.py → layout/__init__.py}

@@ -1,5 +1,6 @@
 import PySimpleGUI as sg
 from typing import List, Tuple, Any
+from is_matrix_forge.designer_gui.main_window.layout.button_grid.column import build_grid_frame
 
 
 class PixelGridLayout:
@@ -93,12 +94,7 @@ class PixelGridLayout:
         self.__button_list = value
 
     def build(self) -> List[List[Any]]:
-        grid = [
-            [sg.Button(' ', size=self.button_size, key=(col, row), pad=self.pad)
-             for col in range(self.width)]
-            for row in range(self.height)
-        ]
-        grid_column = sg.Column(grid)
+        grid_column = build_grid_frame(self.width, self.height, button_size=self.button_size, pad=self.pad)
 
         controls = [[sg.Button(btn)] for btn in self.button_list]
         control_column = sg.Column(controls, vertical_alignment='top')

is_matrix_forge/designer_gui/main_window/layout/button_grid/column.py

@@ -0,0 +1,17 @@
+import PySimpleGUI as sg
+
+
+def build_grid_frame(num_cols=9, num_rows=34, button_size=(2,1), pad=(1,1)):
+    """Return a layout of 9 vertical columns (of 34 buttons each), side by side."""
+    return [
+        [
+            sg.Column(
+                [
+                    [sg.Button(' ', key=(col, row), size=button_size, pad=pad)]
+                    for row in range(num_rows)
+                ],
+                pad=(0,0)
+            )
+            for col in range(num_cols)
+        ]
+    ]

is_matrix_forge/designer_gui/main_window/layout/button_grid/grid.py

@@ -0,0 +1,15 @@
+import PySimpleGUI as sg
+
+
+def build_button_grid(num_cols, num_rows, button_size=(1, 1), pad=(1, 1)):
+    """
+    Returns a list of `num_cols` lists, each containing `num_rows` buttons.
+    So: 9 columns of 34 rows each.
+    """
+    return [
+        [sg.Button(' ', key=(col, row), size=button_size, pad=pad)]
+         for row in range(num_rows)
+    ],
+        for col in range(num_cols)
+    ]
+

is_matrix_forge/designer_gui/main_window/streamlit_app.py

@@ -0,0 +1,93 @@
+import streamlit as st
+import json
+import copy
+
+class Frame:
+    def __init__(self, grid, duration=1.0):
+        self.grid = grid
+        self.duration = duration
+
+class PixelGridWeb:
+    def __init__(self, width=9, height=34):
+        self.width = width
+        self.height = height
+        if "frames" not in st.session_state:
+            st.session_state.frames = [Frame(self._new_grid())]
+        if "current_frame" not in st.session_state:
+            st.session_state.current_frame = 0
+
+    def _new_grid(self):
+        return [[0 for _ in range(self.height)] for _ in range(self.width)]
+
+    @property
+    def frames(self):
+        return st.session_state.frames
+
+    @frames.setter
+    def frames(self, value):
+        st.session_state.frames = value
+
+    @property
+    def current_frame(self):
+        return st.session_state.current_frame
+
+    @current_frame.setter
+    def current_frame(self, value):
+        st.session_state.current_frame = value
+
+    @property
+    def grid(self):
+        return self.frames[self.current_frame].grid
+
+    def draw(self):
+        st.title("PixelGrid Animator")
+        st.write(f"Frame {self.current_frame+1}/{len(self.frames)}")
+        # Render grid
+        grid = self.grid
+        for row in range(self.height):
+            cols = st.columns(self.width)
+            for col in range(self.width):
+                key = f"pix_{col}_{row}_{self.current_frame}"
+                is_on = grid[col][row]
+                label = "🟩" if is_on else "⬛"
+                if cols[col].button(label, key=key, use_container_width=True):
+                    grid[col][row] ^= 1  # Toggle
+
+        # Frame controls
+        c1, c2, c3, c4 = st.columns(4)
+        if c1.button("Prev", disabled=self.current_frame == 0):
+            self.current_frame -= 1
+        if c2.button("Next", disabled=self.current_frame == len(self.frames)-1):
+            self.current_frame += 1
+        if c3.button("Add Frame"):
+            self.frames.append(Frame(copy.deepcopy(self.grid)))
+            self.current_frame = len(self.frames) - 1
+        if c4.button("Delete Frame", disabled=len(self.frames) == 1):
+            self.frames.pop(self.current_frame)
+            self.current_frame = max(0, self.current_frame-1)
+        # Export/import
+        st.markdown("---")
+        exp1, exp2, exp3 = st.columns(3)
+        if exp1.button("Export JSON"):
+            st.download_button(
+                "Download JSON",
+                data=json.dumps([f.grid for f in self.frames]),
+                file_name="frames.json",
+                mime="application/json"
+            )
+        uploaded = exp2.file_uploader("Load JSON", type="json")
+        if uploaded:
+            data = json.load(uploaded)
+            if isinstance(data, list) and all(isinstance(frame, list) for frame in data):
+                self.frames = [Frame(copy.deepcopy(g)) for g in data]
+                self.current_frame = 0
+        # Placeholder for "Send to Matrix"
+        if exp3.button("Send to Matrix"):
+            st.info("This would send to your matrix (not implemented here)!")
+
+def main():
+    pg = PixelGridWeb()
+    pg.draw()
+
+if __name__ == "__main__":
+    main()

is_matrix_forge/dev_tools/__init__.py

@@ -3,6 +3,6 @@ Author: Taylor B. tayjaybabee@gmail.com
 Date: 2025-05-05 15:02:58
 LastEditors: Taylor B. tayjaybabee@gmail.com
 LastEditTime: 2025-05-05 15:24:08
-FilePath: is_matrix_forge/dev_tools/__init__.py
+FilePath: is_matrix_forge/dev_tools/grid.py
 Description: 这是默认设置,可以在设置》工具》File Description中进行配置
 """

is_matrix_forge/inputmodule/ledmatrix.py

@@ -40,22 +40,6 @@ PWM_FREQUENCIES = [
 ]
 
 
-def get_pwm_freq(dev):
-    """Adjust the brightness scaling of the entire screen."""
-    res = send_command(dev, CommandVals.PwmFreq, with_response=True)
-    freq = int(res[0])
-    if freq == 0:
-        return 29000
-    elif freq == 1:
-        return 3600
-    elif freq == 2:
-        return 1800
-    elif freq == 3:
-        return 900
-    else:
-        return None
-
-
 def percentage(dev, p):
     """Fill a percentage of the screen. Bottom to top"""
     send_command(dev, CommandVals.Pattern, [PatternVals.Percentage, p])

is_matrix_forge/led_matrix/Scripts/__init__.py

@@ -1,4 +1,4 @@
 """
-Fake `__init__.py` to make the Scripts directory a sub-package.
+Fake `grid.py` to make the Scripts directory a sub-package.
 """
 

is_matrix_forge/led_matrix/Scripts/identify_matrices.py

@@ -0,0 +1,228 @@
+"""
+The main entrypoint for the `led-matrix-identify` command.
+
+Description:
+    This module contains the entrypoint for the `led-matrix-identify` command, which
+    is used to identify:
+
+        * Which LED matrix can be communicated with by which serial port
+        * The physical location of each LED matrix
+
+
+See `main()` for more information.
+
+Author:
+    Taylor B. <t.blackstone@inspyre.tech>
+
+Since:
+    v1.0.0
+"""
+import argparse
+from argparse import ArgumentParser
+from threading import Thread
+from typing import List, Optional, Union
+
+from is_matrix_forge.led_matrix.controller.controller import LEDMatrixController
+from is_matrix_forge.led_matrix.constants import DEVICES
+
+
+DEFAULT_RUNTIME = 30
+DEFAULT_CYCLES  = 3
+
+
+def find_leftmost_matrix(matrices: List[LEDMatrixController]) -> Optional[LEDMatrixController]:
+    """
+    Determine the leftmost (physically) LED matrix.
+
+    Parameters:
+        matrices (List[LEDMatrixController]):
+            The controller objects for all LED matrices.
+
+    Returns:
+        Optional[LEDMatrixController]:
+            The controller object representing the determined leftmost matrix, `None`
+            if none found.
+    """
+    if left_devices := [m for m in matrices if m.side_of_keyboard == 'left']:
+        return min(left_devices, key=lambda m: m.slot)
+
+    # Fallback: use right-side devices if no left-side
+    right_devices = [m for m in matrices if m.side_of_keyboard == 'right']
+
+    return min(right_devices, key=lambda m: m.slot) if right_devices else None
+
+
+def find_rightmost_matrix(matrices: List[LEDMatrixController]) -> Optional[LEDMatrixController]:
+    """
+    Determine the rightmost (physically) LED matrix.
+
+    Parameters:
+        matrices (List[LEDMatrixController]):
+            The controller objects for alll LED matrices.
+
+    Returns:
+        Optional[LEDMatrixController]:
+            The controller object representing the determined rightmost matrix, `None`
+            if none found.
+    """
+
+    if right_devices := [m for m in matrices if m.side_of_keyboard == 'right']:
+        return max(right_devices, key=lambda m: m.slot)
+
+    # Fallback: use left-side devices if no right-side
+    left_devices = [m for m in matrices if m.side_of_keyboard == 'left']
+
+    return max(left_devices, key=lambda m: m.slot) if left_devices else None
+
+
+class Arguments(ArgumentParser):
+    def __init__(self):
+        super().__init__('IdentifyLEDMatrices')
+        self.__parsed = None
+
+        # Set up the arguments
+        self.add_argument(
+            '--runtime', '-t',
+            action='store',
+            default=DEFAULT_RUNTIME,
+            help='The total runtime'
+        )
+
+        self.add_argument(
+            '--skip-clear',
+            action='store_true',
+            default=False,
+            help='Skip clearing LEDs'
+        )
+
+        self.add_argument(
+            '-c', '--cycle-count',
+            action='store',
+            type=int,
+            default=DEFAULT_CYCLES,
+            help='The number of cycles to run per message, for each selected device.'
+        )
+
+        # Set up the mutually exclusive arguments for the left and right matrices
+        left_right = self.add_mutually_exclusive_group()
+
+        left_right.add_argument(
+            '-R', '--only-right',
+            action='store_true',
+            default=False,
+            help='Only display identifying information for/on the rightmost matrix.'
+        )
+
+        left_right.add_argument(
+            '-L', '--only-left',
+            action='store_true',
+            default=False,
+            help='Only display identifying information for/on the leftmost matrix.'
+        )
+
+    @property
+    def parsed(self) -> Optional[argparse.Namespace]:
+        """
+        The parsed arguments (if they've been parsed).
+
+        Returns:
+            argparse.Namespace:
+                The parsed arguments.
+
+            None:
+                If the arguments have not yet been parsed.
+        """
+        return self.__parsed
+
+    def parse_args(self, *args, **kwargs):
+        """
+        (Overrides the parent method, since we need to cache the parsed arguments. Does only that and then calls the
+        parent method.)
+
+        Parameters:
+            *args:
+            **kwargs:
+
+        Returns:
+            argparse.Namespace:
+                The parsed arguments
+        """
+        self.__parsed = super().parse_args(*args, **kwargs)
+        return self.__parsed
+
+
+def main(
+    runtime:     Optional[Union[int, float]] = None,
+    only_left:   Optional[bool]              = None,
+    only_right:  Optional[bool]              = None,
+    skip_clear:  Optional[bool]              = None,
+    cycle_count: Optional[int]               = None
+):
+    """
+    The main function of the script.
+
+    Parameters:
+        runtime (Optional[Union[int, float]]):
+            The total runtime in seconds.
+
+        only_left (Optional[bool]):
+            Only display identifying information for/on the leftmost matrix.
+
+        only_right (Optional[bool]):
+            Only display identifying information for/on the rightmost matrix.
+
+        skip_clear (Optional[bool]):
+            Skip clearing LEDs.
+
+        cycle_count (Optional[int]):
+            The number of cycles to run per message, for each selected device.
+
+    Returns:
+        List[Thread]:
+            A list of threads, one for each LED matrix being identified.
+    """
+    selected = [LEDMatrixController(device, 100, thread_safe=True) for device in DEVICES]
+
+    if not skip_clear:
+        skip_clear = ARGS.parsed.skip_clear
+
+    if only_left is None:
+        only_left = ARGS.parsed.only_left
+
+    if only_right is None:
+        only_right = ARGS.parsed.only_right
+
+    if only_right:
+        selected = [find_rightmost_matrix(selected)]
+    elif only_left:
+        selected = [find_leftmost_matrix(selected)]
+
+    cycle_count = ARGS.parsed.cycle_count if cycle_count is None else cycle_count
+
+    if runtime is None:
+        runtime = ARGS.parsed.runtime
+
+    threads = []
+
+    threads.extend(
+        Thread(
+            target=device.identify,
+            kwargs={
+                'skip_clear': skip_clear,
+                'duration':   runtime,
+                'cycles':     cycle_count
+            },
+        )
+        for device in selected
+    )
+    for t in threads:
+        t.start()
+
+    return threads
+
+
+ARGS   = Arguments()
+PARSED = ARGS.parse_args()
+
+if __name__ == '__main__':
+    threads = main()

is_matrix_forge/led_matrix/__init__.py

@@ -1,7 +1,58 @@
+import json
+from is_matrix_forge.led_matrix.controller import LEDMatrixController, get_controllers
+from is_matrix_forge.led_matrix.display.text.scroller import scroll_text_on_multiple_matrices
+from platformdirs import PlatformDirs
 
 
-def get_controllers():
-    from is_matrix_forge.led_matrix.controller.controller import LEDMatrixController
-    from is_matrix_forge.led_matrix.constants import DEVICES
+PLATFORM_DIRS = PlatformDirs("IS-Matrix-Forge", "Inspyre Softworks")
+
+
+APP_DIR = PLATFORM_DIRS.user_data_path
+MEMORY_FILE = APP_DIR / 'memory.ini'
+
+
+MEMORY_FILE_TEMPLATE = {
+    'first_run': True
+}
+
+first_run = False
+
+APP_DIR.mkdir(parents=True, exist_ok=True)
+
+if not MEMORY_FILE.exists():
+    MEMORY_FILE.write_text(json.dumps(MEMORY_FILE_TEMPLATE))
+
+
+def get_first_run():
+    global first_run
+    with open(MEMORY_FILE, 'r') as f:
+        memory = json.load(f)
+    first_run = memory['first_run']
+    return first_run
+
+
+def set_first_run():
+    global first_run
+    with open(MEMORY_FILE, 'r') as f:
+        memory = json.load(f)
+
+    memory['first_run'] = False
+
+    with open(MEMORY_FILE, 'w') as f:
+        json.dump(memory, f)
+
+
+def process_first_run():
+    global first_run
+    fr = get_first_run()
+
+    if fr:
+        controllers = get_controllers(threaded=True)
+        scroll_text_on_multiple_matrices(controllers, 'Welcome!', threaded=True)
+
+    set_first_run()
+
+
+process_first_run()
+
 
-    return [LEDMatrixController(device, 100) for device in DEVICES]

is_matrix_forge/led_matrix/commands/__init__.py

@@ -8,77 +8,12 @@ Project:
     led-matrix-battery
 
 File: 
-    is_matrix_forge/led_matrix/commands/__init__.py
+    is_matrix_forge/led_matrix/commands/grid.py
  
 
 Description:
     
 
 """
-from typing import List, Optional, ByteString
 
-import serial
-from serial.tools.list_ports_common import ListPortInfo
 
-from is_matrix_forge.led_matrix.constants import RESPONSE_SIZE, FWK_MAGIC
-from is_matrix_forge.led_matrix.helpers import disconnect_dev
-
-
-def send_command_raw(dev: ListPortInfo, command: List[int], with_response: bool = False, response_size: Optional[int] = None) -> Optional[ByteString]:
-    """
-    Send a command to the device using a new serial connection.
-
-    Args:
-        dev (ListPortInfo): The device to send the command to.
-        command (List[int]): The command to send.
-        with_response (bool, optional): Whether to wait for a response from the device. Defaults to False.
-        response_size (Optional[int], optional): The size of the response to expect. Defaults to None.
-
-    Returns:
-        Optional[ByteString]: The response from the device, if any, or None if no response or an error occurred.
-
-    Raises:
-        IOError, OSError: If there is an error communicating with the device.
-    """
-    # print(f"Sending command: {command}")
-    res_size = response_size or RESPONSE_SIZE
-    try:
-        with serial.Serial(dev.device, 115200) as s:
-            s.write(command)
-
-            return s.read(res_size) if with_response else None
-    except (IOError, OSError) as _ex:
-        disconnect_dev(dev.device)
-        return None
-        # print("Error: ", ex)
-
-
-def send_command(
-        dev:           ListPortInfo,
-        command:       int,
-        parameters:    Optional[List[int]] = None,
-        with_response: bool                = False
-) -> Optional[ByteString]:
-    """
-    Send a command to the device using a new serial connection.
-
-    Parameters:
-        dev (ListPortInfo):
-            The device to send the command to.
-
-        command (int):
-            The command to send.
-
-        parameters (Optional[List[int]], optional):
-            The parameters to send with the command. Defaults to None.
-
-        with_response (bool, optional):
-            Whether to wait for a response from the device. Defaults to False.
-
-    Returns:
-        Optional[ByteString]:
-            The response from the device, if any, or None if no response or an error occurred.
-    """
-    if parameters is None:
-        parameters = []
-    return send_command_raw(dev, FWK_MAGIC + [command] + parameters, with_response)

is_matrix_forge/led_matrix/constants.py

@@ -11,6 +11,7 @@ This module defines various constants used throughout the application, including
 """
 from is_matrix_forge.common.dirs import PRESETS_DIR
 
+
 # Hardware identifiers
 FWK_MAGIC = [0x32, 0xAC]
 PID       = 0x20