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

is_matrix_forge/designer_gui/main_window/__init__.py

@@ -0,0 +1,252 @@
+import json
+from typing import List, Tuple, Any, Dict
+import PySimpleGUI as sg
+import copy
+import os
+
+from ...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
+
+
+def _normalize(key: Any) -> str:
+    s = str(key)
+    for ch in " <>,'()":
+        s = s.replace(ch, '_')
+    return s.strip('_')
+
+
+class PixelGrid:
+    """
+    LED matrix pixel grid UI with frame-by-frame animation.
+    """
+    def __init__(self, width: int = 9, height: int = 34):
+        self.__width = None
+        self.__height = None
+        self.__frames = None
+        self.__current_frame = None
+        self.__grid = None
+        self.__preferred_device = None
+
+        self.width = width
+        self.height = height
+
+        base = [[0] * self.height for _ in range(self.width)]
+        Frame.__width = self.width
+        Frame.__height = self.height
+        self.frames = [Frame(copy.deepcopy(base))]
+        self.current_frame = 0
+        self.grid = self.frames[0].grid
+        self.preferred_device = None
+
+        layout = PixelGridLayout(self.width, self.height).build()
+        self.window = sg.Window('Pixel Grid', layout, finalize=True)
+        self._init_button_colors()
+        self._update_frame_indicator()
+
+    @property
+    def width(self) -> int:
+        return self.__width
+
+    @width.setter
+    def width(self, value: Any) -> None:
+        if not isinstance(value, int) or value <= 0:
+            raise TypeError("Width must be a positive integer")
+        self.__width = value
+
+    @property
+    def height(self) -> int:
+        return self.__height
+
+    @height.setter
+    def height(self, value: Any) -> None:
+        if not isinstance(value, int) or value <= 0:
+            raise TypeError("Height must be a positive integer")
+        self.__height = value
+
+    @property
+    def frames(self) -> List[Frame]:
+        return self.__frames
+
+    @frames.setter
+    def frames(self, value: Any) -> None:
+        if not isinstance(value, list) or len(value) == 0 or not all(isinstance(f, Frame) for f in value):
+            raise TypeError("frames must be a non-empty list of Frame objects")
+        self.__frames = value
+
+    @property
+    def current_frame(self) -> int:
+        return self.__current_frame
+
+    @current_frame.setter
+    def current_frame(self, value: Any) -> None:
+        if not isinstance(value, int) or not (0 <= value < len(self.frames)):
+            raise ValueError("current_frame must be an index into frames list")
+        self.__current_frame = value
+
+    @property
+    def grid(self) -> List[List[int]]:
+        return self.__grid
+
+    @grid.setter
+    def grid(self, value: Any) -> None:
+        if not is_valid_grid(value, self.width, self.height):
+            raise ValueError("Grid must match width/height and be 0/1 values")
+        self.__grid = value
+        # update frame's grid as well
+        if hasattr(self, 'frames') and self.frames:
+            self.frames[self.current_frame].grid = value
+
+    @property
+    def preferred_device(self):
+        return self.__preferred_device
+
+    @preferred_device.setter
+    def preferred_device(self, value: Any) -> None:
+        # no strict type check, but could enforce presence in DEVICES
+        self.__preferred_device = value
+
+    def _init_button_colors(self) -> None:
+        for col in range(self.width):
+            for row in range(self.height):
+                state = self.grid[col][row]
+                color = 'green' if state else 'lightgrey'
+                self.window[(col, row)].update(button_color=('black', color))
+
+    def _update_frame_indicator(self) -> None:
+        total = len(self.frames)
+        idx = self.current_frame + 1
+        dur = self.frames[self.current_frame].duration
+        self.window['FRAME_INDICATOR'].update(
+            f'Frame {idx}/{total} (Duration: {dur}s)'
+        )
+
+    def run(self) -> None:
+        while True:
+            event, _ = self.window.read()
+            if event in (sg.WINDOW_CLOSED, 'Exit'):
+                break
+            handler = getattr(self, f'_handle_{_normalize(event)}', None)
+            if callable(handler):
+                handler(event)
+            elif isinstance(event, tuple):
+                self._toggle_pixel(event)
+        self.window.close()
+
+    def _toggle_pixel(self, key: Tuple[int, int]) -> None:
+        col, row = key
+        new = 1 - self.grid[col][row]
+        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)]
+        self.window[key].update(
+            button_color=('black', 'green' if new else 'lightgrey')
+        )
+
+    # Frame management
+    def add_frame(self) -> None:
+        new_grid = copy.deepcopy(self.grid)
+        frm = Frame(new_grid)
+        self.frames = self.frames + [frm]
+        self.current_frame = len(self.frames) - 1
+        self.grid = frm.grid
+        self._init_button_colors()
+        self._update_frame_indicator()
+
+    def prev_frame(self) -> None:
+        if self.current_frame > 0:
+            self.current_frame -= 1
+            self._load_frame()
+
+    def next_frame(self) -> None:
+        if self.current_frame < len(self.frames) - 1:
+            self.current_frame += 1
+            self._load_frame()
+
+    def _load_frame(self) -> None:
+        frm = self.frames[self.current_frame]
+        self.grid = frm.grid
+        self._init_button_colors()
+        self._update_frame_indicator()
+
+    # Export handlers
+    def _handle_Export(self, _event) -> None:
+        data = [f.grid for f in self.frames] if len(self.frames) > 1 else self.frames[0].grid
+        print(data)
+
+    def _handle_Export_to_File(self, _event) -> None:
+        path = sg.popup_get_file(
+            'Save Grid As', save_as=True, no_window=True,
+            file_types=(('JSON Files', '*.json'),), default_extension='.json'
+        )
+        if not path:
+            return
+        data = [f.grid for f in self.frames] if len(self.frames) > 1 else self.frames[0].grid
+        try:
+            with open(path, 'w') as f:
+                json.dump(data, f)
+            sg.popup('Success', f'Saved to {os.path.basename(path)}')
+        except Exception as e:
+            sg.popup_error('Error', str(e))
+
+    def _handle_Load_from_File(self, _event) -> None:
+        path = sg.popup_get_file(
+            'Load Grid From', no_window=True,
+            file_types=(('JSON Files', '*.json'),)
+        )
+        if not path:
+            return
+        try:
+            raw = json.load(open(path))
+            if is_valid_grid(raw, self.width, self.height):
+                grids = [raw]
+            elif is_valid_frames(raw, self.width, self.height):
+                grids = raw
+            else:
+                sg.popup_error('Invalid format')
+                return
+            self.frames = [Frame(copy.deepcopy(g)) for g in grids]
+            self.current_frame = 0
+            self._load_frame()
+            sg.popup('Success', f'Loaded {len(self.frames)} frame(s)')
+        except Exception as e:
+            sg.popup_error('Error', str(e))
+
+    # Send to matrix
+    def _handle_Send_to_Matrix(self, _event) -> None:
+        devices = DEVICES
+        if not devices:
+            sg.popup_error('No devices found.')
+            return
+        if self.preferred_device in devices:
+            dev = self.preferred_device
+        else:
+            descs = [f"{d.device} - {d.description}" for d in devices]
+            win = sg.Window('Select Device', [
+                [sg.Text('Select device:')],
+                [sg.Listbox(descs, size=(40, len(descs)), key='DEV')],
+                [sg.Checkbox('Always choose', key='REM')],
+                [sg.OK(), sg.Cancel()]
+            ], modal=True)
+            ev, vals = win.read(); win.close()
+            if ev != 'OK' or not vals['DEV']:
+                return
+            dev = devices[descs.index(vals['DEV'][0])]
+            if vals['REM']:
+                self.preferred_device = dev
+        try:
+            render_matrix(dev, self.grid)
+            sg.popup('Success', f'Sent to {dev.device}')
+        except Exception as e:
+            sg.popup_error('Error sending:', str(e))
+
+    # Button-mapped handlers
+    def _handle_Add_Frame(self, e): self.add_frame()
+    def _handle_Prev(self, e): self.prev_frame()
+    def _handle_Next(self, e): self.next_frame()
+
+    def _validate(self, grid: Any) -> bool:
+        return is_valid_grid(grid, self.width, self.height)

is_matrix_forge/designer_gui/main_window/layout.py

@@ -0,0 +1,117 @@
+import PySimpleGUI as sg
+from typing import List, Tuple, Any
+
+
+class PixelGridLayout:
+    """
+    Builds the PySimpleGUI layout for the pixel grid, control panel,
+    and frame animation controls.
+    """
+    def __init__(
+        self,
+        width: int = 9,
+        height: int = 34,
+        button_list: List[str] = None,
+        pad: Tuple[int, int] = (0, 0),
+        button_size: Tuple[int, int] = (2, 1)
+    ):
+        # initialize backing fields
+        self.__width = None
+        self.__height = None
+        self.__pad = None
+        self.__button_size = None
+        self.__button_list = None
+        # assign via properties
+        self.width = width
+        self.height = height
+        self.pad = pad
+        self.button_size = button_size
+        self.button_list = button_list or [
+            'Export', 'Export to File', 'Load from File',
+            'Send to Matrix', 'Add Frame', 'Exit'
+        ]
+
+    @property
+    def width(self) -> int:
+        return self.__width
+
+    @width.setter
+    def width(self, value: Any) -> None:
+        if not isinstance(value, int) or value <= 0:
+            raise TypeError("Width must be a positive integer")
+        self.__width = value
+
+    @property
+    def height(self) -> int:
+        return self.__height
+
+    @height.setter
+    def height(self, value: Any) -> None:
+        if not isinstance(value, int) or value <= 0:
+            raise TypeError("Height must be a positive integer")
+        self.__height = value
+
+    @property
+    def pad(self) -> Tuple[int, int]:
+        return self.__pad
+
+    @pad.setter
+    def pad(self, value: Any) -> None:
+        if (
+            not isinstance(value, tuple)
+            or len(value) != 2
+            or not all(isinstance(v, int) for v in value)
+        ):
+            raise TypeError("pad must be a tuple of two integers")
+        self.__pad = value
+
+    @property
+    def button_size(self) -> Tuple[int, int]:
+        return self.__button_size
+
+    @button_size.setter
+    def button_size(self, value: Any) -> None:
+        if (
+            not isinstance(value, tuple)
+            or len(value) != 2
+            or not all(isinstance(v, int) for v in value)
+        ):
+            raise TypeError("button_size must be a tuple of two integers")
+        self.__button_size = value
+
+    @property
+    def button_list(self) -> List[str]:
+        return self.__button_list
+
+    @button_list.setter
+    def button_list(self, value: Any) -> None:
+        if (
+            not isinstance(value, list)
+            or not all(isinstance(v, str) for v in value)
+        ):
+            raise TypeError("button_list must be a list of strings")
+        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)
+
+        controls = [[sg.Button(btn)] for btn in self.button_list]
+        control_column = sg.Column(controls, vertical_alignment='top')
+
+        frame_controls = [
+            sg.Button('< Prev', key='<Prev>'),
+            sg.Text('', key='FRAME_INDICATOR'),
+            sg.Button('Next >', key='Next>')
+        ]
+
+        layout = [
+            [grid_column, sg.VerticalSeparator(), control_column],
+            [sg.HorizontalSeparator(pad=(0, 5))],
+            [sg.Push(), *frame_controls, sg.Push()]
+        ]
+        return layout

is_matrix_forge/dev_tools/__init__.py

@@ -0,0 +1,8 @@
+"""
+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
+Description: 这是默认设置,可以在设置》工具》File Description中进行配置
+"""

is_matrix_forge/dev_tools/debug.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+from platformdirs import PlatformDirs
+from easy_exit_calls import ExitCallHandler
+from is_matrix_forge.log_engine import ROOT_LOGGER as PARENT_LOGGER
+
+MOD_LOGGER = PARENT_LOGGER.get_child('monitor.gui.debug')
+
+DEBUG_MODE_KEYFILE_NAME = 'marauder.map'
+
+ECH: ExitCallHandler
+
+PLATFORM_DIRS = PlatformDirs('LEDMatrixPowerMonitor', 'Inspyre-Softworks')
+
+
+def get_debug_mode_keyfile_path():
+    return PLATFORM_DIRS.user_data_path
+
+
+MARAUDER_FILE_PATH = get_debug_mode_keyfile_path()
+
+
+def create_marauders_map(mm_path=MARAUDER_FILE_PATH):
+    log = MOD_LOGGER.get_child('create_marauders_map')
+    mm_path = Path(mm_path).expanduser().resolve()
+    log.debug(f'Creating Marauder\'s Map at {mm_path}')
+
+    if not mm_path.parent.exists():
+        log.debug(f'Creating parent directory for Marauder\'s Map: {mm_path.parent}')
+        mm_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(mm_path, 'w') as f:
+        f.write('Mooney, Wormtail, Padfoot, and Prongs are proud to present the Marauder\'s Map.')
+
+    log.debug(f'Marauder\'s Map created at {mm_path}')
+
+
+def disable_debug_mode(mm_file_path=MARAUDER_FILE_PATH):
+    log = MOD_LOGGER.get_child('disable_debug_mode')
+    mm_file_path = Path(mm_file_path).expanduser().resolve()
+    log.debug(f'Writing magic words to Marauder\'s Map at {mm_file_path}')
+
+    if not mm_file_path.exists():
+        log.warning(f'Marauder\'s Map file does not exist: {mm_file_path}. (No debug mode to disable)')
+        raise RuntimeError(f'Marauder\'s Map file does not exist: {mm_file_path}. (No debug mode to disable)')
+
+    with open(MARAUDER_FILE_PATH, 'w') as f:
+        f.write('Mischief Managed.')
+    log.debug(f'Magic words written to Marauder\'s Map at {mm_file_path}')
+
+    if 'ECH' in globals() and globals()['ECH'].function_registered(disable_debug_mode):
+        log.debug(f'Found ExitCallHandler instance with registered function: {disable_debug_mode}. Unregistering it.')
+        globals()['ECH'].unregister_handler(disable_debug_mode)
+        log.debug('Unregistered ExitCallHandler instance with registered function: {disable_debug_mode}.')
+
+
+def enable_debug_mode(
+        mm_file_path=MARAUDER_FILE_PATH,
+        disable_on_exit=False,
+):
+    mm_file_path = Path(mm_file_path).expanduser().resolve()
+
+    if not mm_file_path.exists():
+        create_marauders_map(mm_file_path)
+
+    with open(MARAUDER_FILE_PATH, 'w') as f:
+        f.write('I solemnly swear that I am up to no good.')
+
+    if disable_on_exit:
+        from easy_exit_calls import ExitCallHandler
+        global ECH
+        ech = ExitCallHandler()
+        ech.register_handler(disable_debug_mode, mm_file_path)
+
+
+def is_debug_mode(portkey_file_path=MARAUDER_FILE_PATH):
+    try:
+        with open(portkey_file_path, 'r') as f:
+            # Check if the file contains the correct content
+            content = f.read()
+            return content.strip() == 'I solemnly swear that I am up to no good.'
+    except FileNotFoundError:
+        return False

is_matrix_forge/dev_tools/presets.py

@@ -0,0 +1,47 @@
+"""
+
+
+Author: 
+    Inspyre Softworks
+
+Project:
+    led-matrix-battery
+
+File: 
+    is_matrix_forge/dev_tools/presets.py
+ 
+
+Description:
+    
+
+"""
+from pathlib import Path
+from typing import Union, Optional
+from is_matrix_forge.common.dirs import PRESETS_DIR
+from is_matrix_forge.led_matrix.constants import PROJECT_URLS
+import requests
+
+
+MANIFEST_FILE_NAME = 'manifest.json'
+REMOTE_MANIFEST_URL = PROJECT_URLS['github_api'] + '/' + MANIFEST_FILE_NAME
+
+
+def get_remote_manifest():
+    """
+    Download the remote preset manifest file.
+
+    Returns:
+        dict:
+            The JSON content of the remote manifest file.
+
+    Raises:
+        requests.RequestException:
+            If there is an error during the HTTP request.
+    """
+    res = requests.get(REMOTE_MANIFEST_URL)
+    res.raise_for_status()
+
+    data = res.json()
+
+    return data
+

is_matrix_forge/inputmodule/__init__.py

@@ -0,0 +1,164 @@
+from enum import IntEnum
+import serial
+
+DISCONNECTED_DEVS = []
+FWK_MAGIC = [0x32, 0xAC]
+FWK_VID = 0x32AC
+LED_MATRIX_PID = 0x20
+QTPY_PID = 0x001F
+INPUTMODULE_PIDS = [LED_MATRIX_PID, QTPY_PID]
+
+
+def disconnect_dev(dev):
+    """
+    Disconnect the device from the system.
+
+    Parameters:
+        dev (str):
+            The device to disconnect.
+    """
+    global DISCONNECTED_DEVS
+    if dev in DISCONNECTED_DEVS:
+        return
+    DISCONNECTED_DEVS.append(dev)
+
+
+class CommandVals(IntEnum):
+    Brightness = 0x00
+    Pattern = 0x01
+    BootloaderReset = 0x02
+    Sleep = 0x03
+    Animate = 0x04
+    Panic = 0x05
+    Draw = 0x06
+    StageGreyCol = 0x07
+    DrawGreyColBuffer = 0x08
+    SetText = 0x09
+    StartGame = 0x10
+    GameControl = 0x11
+    GameStatus = 0x12
+    SetColor = 0x13
+    DisplayOn = 0x14
+    InvertScreen = 0x15
+    SetPixelColumn = 0x16
+    FlushFramebuffer = 0x17
+    ClearRam = 0x18
+    ScreenSaver = 0x19
+    SetFps = 0x1A
+    SetPowerMode = 0x1B
+    PwmFreq = 0x1E
+    DebugMode = 0x1F
+    Version = 0x20
+
+
+class Game(IntEnum):
+    Snake = 0x00
+    Pong = 0x01
+    Tetris = 0x02
+    GameOfLife = 0x03
+
+
+class PatternVals(IntEnum):
+    Percentage = 0x00
+    Gradient = 0x01
+    DoubleGradient = 0x02
+    DisplayLotus = 0x03
+    ZigZag = 0x04
+    FullBrightness = 0x05
+    DisplayPanic = 0x06
+    DisplayLotus2 = 0x07
+
+
+class GameOfLifeStartParam(IntEnum):
+    Currentmatrix = 0x00
+    Pattern1 = 0x01
+    Blinker = 0x02
+    Toad = 0x03
+    Beacon = 0x04
+    Glider = 0x05
+
+    def __str__(self):
+        return self.name.lower()
+
+    def __repr__(self):
+        return str(self)
+
+    @staticmethod
+    def argparse(s):
+        try:
+            return GameOfLifeStartParam[s.lower().capitalize()]
+        except KeyError:
+            return s
+
+
+class GameControlVal(IntEnum):
+    Up = 0
+    Down = 1
+    Left = 2
+    Right = 3
+    Quit = 4
+
+
+RESPONSE_SIZE = 32
+
+
+def bootloader_jump(dev):
+    """Reboot into the bootloader to flash new firmware"""
+    send_command(dev, CommandVals.BootloaderReset, [0x00])
+
+
+def brightness(dev, b: int):
+    """Adjust the brightness scaling of the entire screen."""
+    send_command(dev, CommandVals.Brightness, [b])
+
+
+def get_brightness(dev):
+    """Adjust the brightness scaling of the entire screen."""
+    res = send_command(dev, CommandVals.Brightness, with_response=True)
+    return int(res[0])
+
+
+def get_version(dev):
+    """Get the device's firmware version"""
+    res = send_command(dev, CommandVals.Version, with_response=True)
+    if not res:
+        return 'Unknown'
+    major = res[0]
+    minor = (res[1] & 0xF0) >> 4
+    patch = res[1] & 0xF
+    pre_release = res[2]
+
+    version = f"{major}.{minor}.{patch}"
+    if pre_release:
+        version += " (Pre-release)"
+    return version
+
+
+def send_command(dev, command, parameters=[], with_response=False):
+    return send_command_raw(dev, FWK_MAGIC + [command] + parameters, with_response)
+
+
+def send_command_raw(dev, command, with_response=False):
+    """Send a command to the device.
+    Opens new serial connection every time"""
+    # print(f"Sending command: {command}")
+    try:
+        with serial.Serial(dev.device, 115200) as s:
+            s.write(command)
+
+            if with_response:
+                res = s.read(RESPONSE_SIZE)
+                # print(f"Received: {res}")
+                return res
+    except (IOError, OSError) as _ex:
+        disconnect_dev(dev.device)
+        # print("Error: ", ex)
+
+
+def send_serial(dev, s, command):
+    """Send serial command by using existing serial connection"""
+    try:
+        s.write(command)
+    except (IOError, OSError) as _ex:
+        disconnect_dev(dev.device)
+        # print("Error: ", ex)