benchlab-pytools 3.0.0__py3-none-any.whl

benchlab/wigidash/benchlab_ui.py

@@ -0,0 +1,190 @@
+from PIL import Image, ImageFont
+import os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+ASSETS_DIR = os.path.join(BASE_DIR, "assets")
+
+
+class UITheme:
+    SCREEN_WIDTH = 1016
+    SCREEN_HEIGHT = 592
+    HEADER_HEIGHT = 60
+    FOOTER_HEIGHT = 56
+    PADDING = 8
+
+    COLOR_SECTION = (252, 228, 119)
+    COLOR_BG = (0, 0, 0)
+    COLOR_CARD = (15, 15, 15)
+    COLOR_TEXT = (238, 238, 238)
+    COLOR_MUTED = (128, 128, 128)
+    COLOR_BORDER = (200, 200, 200)
+
+
+class UIButton:
+    SELECT_DEVICE = "select_device"
+    OVERVIEW = "overview"
+    SHUTDOWN = "shutdown"
+    GRAPH_METRIC = "graph_metric"
+
+
+BUTTON_DEFS = {
+    UIButton.SELECT_DEVICE: {
+        "text": "Select Device",
+        "color": (252, 228, 119),
+    },
+    UIButton.OVERVIEW: {
+        "text": "Overview",
+        "color": (252, 228, 119),
+    },
+    UIButton.SHUTDOWN: {
+        "text": "Shutdown",
+        "color": (255, 99, 71),
+    },
+    UIButton.GRAPH_METRIC: {
+        "color": (0, 0, 0),
+    },
+}
+
+
+def bind_button(button_id, callback):
+    spec = BUTTON_DEFS[button_id]
+    return {
+        "id": button_id,
+        "text": spec.get("text", ""),
+        "color": spec["color"],
+        "callback": callback,
+    }
+
+
+def load_fonts():
+    try:
+        return {
+            "header": ImageFont.truetype(
+                os.path.join(
+                    ASSETS_DIR,
+                    "Inter-Bold.ttf"),
+                30),
+            "title": ImageFont.truetype(
+                os.path.join(
+                    ASSETS_DIR,
+                    "Inter.ttf"),
+                18),
+            "text": ImageFont.truetype(
+                os.path.join(
+                    ASSETS_DIR,
+                    "Inter.ttf"),
+                14),
+            "button": ImageFont.truetype(
+                os.path.join(
+                    ASSETS_DIR,
+                    "Inter.ttf"),
+                14),
+        }
+    except Exception:
+        default = ImageFont.load_default()
+        return dict(
+            header=default,
+            title=default,
+            text=default,
+            button=default)
+
+
+def load_logo(max_size=(60, 60)):
+    logo_path = os.path.join(ASSETS_DIR, "benchlab.png")
+    try:
+        logo_img = Image.open(logo_path).convert("RGBA")
+        logo_img.thumbnail(max_size, Image.Resampling.LANCZOS)
+        return logo_img
+    except Exception:
+        # Optionally log warning here if you have a logger
+        return None
+
+
+def draw_header(draw, img, fonts, title, logo=None):
+    draw.rectangle([0,
+                    0,
+                    UITheme.SCREEN_WIDTH,
+                    UITheme.HEADER_HEIGHT],
+                   fill=UITheme.COLOR_SECTION)
+
+    if logo:
+        y = (UITheme.HEADER_HEIGHT - logo.height) // 2
+        img.paste(logo, (10, y), mask=logo)
+        img.paste(logo, (UITheme.SCREEN_WIDTH - logo.width - 10, y), mask=logo)
+
+    bbox = draw.textbbox((0, 0), title, font=fonts["header"])
+    x = (UITheme.SCREEN_WIDTH - (bbox[2] - bbox[0])) // 2
+    y = (UITheme.HEADER_HEIGHT - (bbox[3] - bbox[1])) // 2
+    draw.text((x, y), title, fill=(0, 0, 0), font=fonts["header"])
+
+
+def draw_footer(draw, fonts, info_text, buttons):
+    hitboxes = []
+    pad = UITheme.PADDING
+
+    footer_top = UITheme.SCREEN_HEIGHT - UITheme.FOOTER_HEIGHT
+    footer_bottom = UITheme.SCREEN_HEIGHT
+
+    # Inner content area (accounts for padding + border)
+    inner_top = footer_top + pad
+    inner_bottom = footer_bottom - pad
+    inner_height = inner_bottom - inner_top
+
+    # ---- Layout calculations ----
+    btn_w = 120
+    btn_h = inner_height  # EXACT same height as info box
+    total_btn_width = len(buttons) * btn_w + (len(buttons) - 1) * pad
+
+    info_right = UITheme.SCREEN_WIDTH - pad - total_btn_width - pad
+
+    # ---- Info background ----
+    draw.rectangle(
+        [pad, inner_top, info_right, inner_bottom],
+        fill=(20, 20, 20),
+        outline=UITheme.COLOR_BORDER
+    )
+
+    # ---- Info text (vertically centered in inner area) ----
+    tb = fonts["text"].getbbox(info_text)
+    text_h = tb[3] - tb[1]
+    text_y = inner_top + (inner_height - text_h) // 2
+
+    draw.text(
+        (pad + 8, text_y),
+        info_text,
+        fill=UITheme.COLOR_TEXT,
+        font=fonts["text"]
+    )
+
+    # ---- Buttons ----
+    x = UITheme.SCREEN_WIDTH - pad - btn_w
+
+    for btn in buttons:
+        y = inner_top
+
+        draw.rectangle(
+            [x, y, x + btn_w, y + btn_h],
+            fill=btn["color"],
+            outline=UITheme.COLOR_BORDER
+        )
+
+        # Center text inside button
+        tb = fonts["button"].getbbox(btn["text"])
+        tx = x + (btn_w - (tb[2] - tb[0])) // 2
+        ty = y + (btn_h - (tb[3] - tb[1])) // 2
+
+        draw.text((tx, ty), btn["text"], fill=(0, 0, 0), font=fonts["button"])
+
+        # Hitbox == button rectangle
+        hitboxes.append({
+            "x0": x,
+            "y0": y,
+            "x1": x + btn_w,
+            "y1": y + btn_h,
+            "callback": btn["callback"],
+            "text": btn["text"]
+        })
+
+        x -= btn_w + pad
+
+    return hitboxes

benchlab/wigidash/benchlab_utils.py

@@ -0,0 +1,182 @@
+# benchlab_utils.py
+
+from PIL import Image
+import logging
+import numpy as np
+import sys
+import time
+import threading
+
+# ----------------------------------------
+# Logging setup
+# ----------------------------------------
+
+# shared logger for all benchlab modules
+
+
+def get_logger(name="BenchlabUtils", level=logging.INFO):
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    # Remove any duplicate handlers
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    ch = logging.StreamHandler(sys.stdout)
+    ch.setFormatter(logging.Formatter(
+        '[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s',
+        datefmt='%H:%M:%S'
+    ))
+    logger.addHandler(ch)
+    logger.propagate = False  # prevent double logging via root logger
+    return logger
+
+
+logger = get_logger("BenchlabUtils")
+
+
+def setup_logging(module_levels=None, default_level=logging.INFO):
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(logging.Formatter(
+        '[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s',
+        datefmt='%H:%M:%S'
+    ))
+
+    root = logging.getLogger()
+    root.setLevel(default_level)
+
+    if not root.hasHandlers():
+        root.addHandler(handler)
+
+    if module_levels:
+        for name, level in module_levels.items():
+            lg = logging.getLogger(name)
+            lg.setLevel(level)
+            if not lg.hasHandlers():
+                lg.addHandler(handler)
+            lg.propagate = False
+
+
+# ----------------------------------------
+# Display / Image helpers
+# ----------------------------------------
+
+def image_to_rgb565(img: Image.Image) -> bytes:
+    """Convert PIL image to raw RGB565 bytes using NumPy (faster)."""
+    img = img.convert('RGB')
+    arr = np.array(img, dtype=np.uint8)  # shape: (H, W, 3)
+
+    r = (arr[..., 0] >> 3).astype(np.uint16)  # 5 bits
+    g = (arr[..., 1] >> 2).astype(np.uint16)  # 6 bits
+    b = (arr[..., 2] >> 3).astype(np.uint16)  # 5 bits
+
+    rgb565 = (r << 11) | (g << 5) | b  # shape: (H, W)
+    return rgb565.flatten().tobytes()
+
+
+def display_image(wigidash, img: Image.Image, page=0, widget_id=0):
+    """Display an image on the WigiDash widget."""
+    if not wigidash:
+        logging.getLogger(__name__).warning(
+            "display_image: no wigidash device")
+        return
+
+    rgb565 = image_to_rgb565(img)
+    wigidash.write_to_widget(
+        page=page,
+        widget_id=widget_id,
+        offset=0,
+        data=rgb565)
+
+
+def clear_display(wigidash, width, height):
+    """Fill the screen with black."""
+    img = Image.new('RGB', (width, height), (0, 0, 0))
+    display_image(wigidash, img)
+    logging.getLogger(__name__).info("Display cleared.")
+
+
+# ----------------------------------------
+# Screen keepalive
+# ----------------------------------------
+
+class KeepAliveManager:
+    """Keeps the WigiDash screen from going to sleep."""
+
+    def __init__(self, wigidash, interval=5.0):
+        self.wigidash = wigidash
+        self.interval = interval
+        self.running = False
+        self.thread = None
+
+    def start(self):
+        if self.running:
+            return
+        self.running = True
+        self.thread = threading.Thread(target=self.loop, daemon=True)
+        self.thread.start()
+
+    def stop(self):
+        self.running = False
+        if self.thread:
+            self.thread.join(timeout=1.0)
+            self.thread = None
+
+    def mark_active(self):
+        try:
+            if self.wigidash and hasattr(
+                    self.wigidash, "clear_screen_timeout"):
+                self.wigidash.clear_screen_timeout()
+        except Exception as e:
+            logger.warning("Keepalive error: %s", e)
+
+    def loop(self):
+        step = 0.1
+        while self.running:
+            try:
+                if self.wigidash:
+                    self.wigidash.clear_screen_timeout()
+            except Exception as e:
+                logger.warning(f"Keepalive error: {e}")
+
+            for _ in range(int(self.interval / step)):
+                if not self.running:
+                    break
+                time.sleep(step)
+
+
+# ----------------------------------------
+# Shutdown function
+# ----------------------------------------
+
+def shutdown_wigidash(wigi_instance):
+    """
+    Safely shut down a WigiDash session.
+
+    wigi_instance: instance of BenchlabWigi or any object
+                   with .keepalive_manager, .wigidash, .usb_dev attributes.
+    """
+    logger.info("Shutting down WigiDash session...")
+
+    # Stop keepalive
+    if getattr(wigi_instance, "keepalive_manager", None):
+        wigi_instance.keepalive_manager.stop()
+
+    # Clear / snooze display
+    wigidash = getattr(wigi_instance, "wigidash", None)
+    if wigidash:
+        try:
+            wigidash.clear_page(0)
+            wigidash.snooze_device()
+        except Exception as e:
+            logger.warning(f"Error shutting down display: {e}")
+
+    # Disconnect USB
+    usb_dev = getattr(wigi_instance, "usb_device", None)
+    if usb_dev:
+        try:
+            logger.info("Disconnecting USB device...")
+            usb_dev.disconnect()
+            logger.info("USB device disconnected.")
+        except Exception as e:
+            logger.warning(f"Error disconnecting USB: {e}")

benchlab/wigidash/requirements.txt

@@ -0,0 +1,9 @@
+Pillow>=11.3.0
+matplotlib>=3.10.7
+numpy>=2.2.0
+pyusb>=1.3.1
+pyserial>=3.5
+
+# Provides a prebuilt libusb-1.0 backend for pyusb on Windows (no conda
+# required) — pyusb auto-discovers it once installed.
+libusb-package>=1.0.26.1; sys_platform == "win32"