streamdeck-gui-ng 4.1.3__py3-none-any.whl

streamdeck_ui/display/filter.py

@@ -0,0 +1,65 @@
+from abc import ABC, abstractmethod
+from fractions import Fraction
+from typing import Callable, Optional, Tuple
+
+from PIL import Image
+
+
+class Filter(ABC):
+    """
+    A filter transforms a given input image to the desired output image. A filter can signal that it
+    is complete and will be removed from the pipeline.
+
+    :param str name: The name of the filter. The name is useful for debugging purposes.
+    """
+
+    size: Tuple[int, int]
+    "The image size (width, height) in pixels that this filter transforms."
+
+    is_complete: bool
+    "Indicates if the filter is complete and should no longer be processed."
+
+    def __init__(self):
+        self.is_complete = False
+
+    @abstractmethod
+    def initialize(self, size: Tuple[int, int]):
+        """Initializes the filter with the provided frame size. Since the construction
+        of the filter can happen before the size of the display is known, initialization
+        should be done here.
+
+        :param size: The filter image size
+        :type size: Tuple[int, int]
+        """
+        pass
+
+    @abstractmethod
+    def transform(
+        self,
+        get_input: Callable[[], Optional[Image.Image]],
+        get_output: Callable[[int], Optional[Image.Image]],
+        input_changed: bool,
+        time: Fraction,
+    ) -> Tuple[Optional[Image.Image], int]:
+        """
+        Transforms the given input image to the desired output image.
+        The default behaviour is to return the orignal image.
+
+        :param Callable[[], PIL.Image] get_input: A function that returns the input image to transform. Note that calling
+        this will create a copy of the input image, and it is safe to manipulate directly.
+
+        :param Callable[[int], PIL.Image] get_output: Provide the hashcode of the new frame and it will
+        return the output frame if it already exists. This avoids having to redraw an output frame that is already
+        cached.
+
+        :param bool input_changed: True if the input is different from previous run, False otherwise.
+        When true, you have to return an Image.
+
+        :param Fraction time: The current time in seconds, expressed as a fractional number since
+        the start of the pipeline.
+
+        :rtype: PIL.Image
+        :return: The transformed output image. If this filter did not modify the input, return None. This signals to the
+        pipeline manager that there was no change and a cached version will be moved to the next stage.
+        """
+        pass

streamdeck_ui/display/image_filter.py

@@ -0,0 +1,144 @@
+import itertools
+import os
+from fractions import Fraction
+from io import BytesIO
+from typing import Callable, Optional, Tuple
+
+import cairosvg
+import filetype
+from PIL import Image, ImageSequence
+
+from streamdeck_ui.config import WARNING_ICON
+from streamdeck_ui.display.filter import Filter
+
+
+class ImageFilter(Filter):
+    """
+    Represents a static image. It transforms the input image by replacing it with a static image.
+    """
+
+    def __init__(self, file: str):
+        super(ImageFilter, self).__init__()
+        self.file = os.path.expanduser(file)
+        try:
+            file_stats = os.stat(file)
+            file_size = file_stats.st_size
+            mod_time = file_stats.st_mtime
+        except BaseException:  # noqa: B036
+            file_size = 0
+            mod_time = 0
+            print(f"Unable to load icon {self.file} to calculate stats.")
+
+        # Create a tuple of the file metadata for creating a hashcode.
+        self.metadata = (self.__class__, self.file, file_size, mod_time)
+
+    def initialize(self, size: Tuple[int, int]):
+        # Each frame needs to have a unique hashcode.
+        image_hash = hash(self.metadata)
+        frame_duration = []
+        frame_hash = []
+
+        try:
+            kind = filetype.guess(self.file)
+            if kind is None:
+                svg_code = open(self.file).read()
+                png = cairosvg.svg2png(svg_code, output_height=size[1], output_width=size[0])
+                image_file = BytesIO(png)
+                image = Image.open(image_file)
+                frame_duration.append(-1)
+                frame_hash.append(image_hash)
+            else:
+                image = Image.open(self.file)
+                image.seek(0)
+                # Frame number is used to create unique hash
+                frame_number = 1
+                while True:
+                    try:
+                        frame_duration.append(image.info["duration"])
+                        # Create tuple and hash it, to combine the image and frame hashcodes
+                        frame_hash.append(hash((image_hash, frame_number)))
+                        image.seek(image.tell() + 1)
+                        frame_number += 1
+                    except EOFError:
+                        # Reached the final frame
+                        break
+                    except KeyError:
+                        # If the key 'duration' can't be found, it's not an animation
+                        frame_duration.append(-1)
+                        frame_hash.append(image_hash)
+                        break
+
+        except BaseException as icon_error:  # noqa: B036
+            # FIXME: caller should handle this?
+            print(f"Unable to load icon {self.file} with error {icon_error}")
+            image = Image.open(WARNING_ICON)
+            frame_duration.append(-1)
+            frame_hash.append(image_hash)
+
+        frames = ImageSequence.Iterator(image)
+
+        # Scale all the frames to the target size
+        self.frames = []
+        for frame, milliseconds, hashcode in zip(frames, frame_duration, frame_hash):
+            frame = frame.copy()
+            if frame.has_transparency_data and frame.mode != "RGBA":
+                try:
+                    frame = frame.convert("RGBA")
+                except BaseException:  # noqa: B036
+                    pass
+            scale_factor = min(size[0] / frame.size[0], size[1] / frame.size[1])
+            frame = frame.resize((int(v * scale_factor) for v in frame.size), Image.Resampling.LANCZOS)
+            self.frames.append((frame, milliseconds, hashcode))
+
+        self.frame_cycle = itertools.cycle(self.frames)
+        self.current_frame = next(self.frame_cycle)
+        self.frame_time = Fraction()
+
+    def transform(  # type: ignore[override]
+        self,
+        get_input: Callable[[], Image.Image],
+        get_output: Callable[[int], Image.Image],
+        input_changed: bool,
+        time: Fraction,
+    ) -> Tuple[Optional[Image.Image], int]:
+        """
+        The transformation returns the loaded image, ando overwrites whatever came before.
+        """
+
+        # Unpack tuple to make code a bit easier to understand
+        frame, duration, hashcode = self.current_frame
+
+        if duration >= 0 and time - self.frame_time > duration / 1000:
+            self.frame_time = time
+            self.current_frame = next(self.frame_cycle)
+
+            # Unpack updated value
+            frame, duration, hashcode = self.current_frame
+
+            image = get_output(hashcode)
+            if image:
+                return (image, hashcode)
+
+            input = get_input()
+            if frame.mode == "RGBA":
+                # Use the transparency mask of the image to paste
+                input.paste(frame, frame)
+            else:
+                input.paste(frame)
+            return (input, hashcode)
+
+        if input_changed:
+            image = get_output(hashcode)
+            if image:
+                return (image, hashcode)
+
+            input = get_input()
+
+            if frame.mode == "RGBA":
+                # Use the transparency mask of the image to paste
+                input.paste(frame, frame)
+            else:
+                input.paste(frame)
+            return (input, hashcode)
+        else:
+            return (None, hashcode)

streamdeck_ui/display/keypress_filter.py

@@ -0,0 +1,63 @@
+from fractions import Fraction
+from typing import Callable, Optional, Tuple
+
+from PIL import Image, ImageEnhance
+
+from streamdeck_ui.display.filter import Filter
+
+
+class KeypressFilter(Filter):
+    """This filter is applied whenever a key is being pressed"""
+
+    last_time: Fraction
+    pulse_delay: float
+    brightness: float
+    dim_brightness: float
+    filter_hash: int
+
+    def __init__(self):
+        super(KeypressFilter, self).__init__()
+        self.last_time = Fraction()
+        self.brightness = 1
+        self.dim_brightness = 0.5
+        self.filter_hash = hash(self.__class__)
+        self.active = False
+        self.last_state = False
+
+    def initialize(self, size: Tuple[int, int]):
+        self.blank_image = Image.new("RGB", size)
+        self.size = size
+        pass
+
+    def transform(  # type: ignore[override]
+        self,
+        get_input: Callable[[], Image.Image],
+        get_output: Callable[[int], Image.Image],
+        input_changed: bool,
+        time: Fraction,
+    ) -> Tuple[Optional[Image.Image], int]:
+        frame_hash = hash((self.filter_hash, self.active))
+        if input_changed or self.active != self.last_state:
+            self.last_state = self.active
+            image = get_output(frame_hash)
+            if image:
+                return (image, frame_hash)
+
+            input = get_input()
+            if self.active:
+                input = get_input()
+                background = self.blank_image.copy()
+                input.thumbnail((self.size[0] - 10, self.size[1] - 10), Image.Resampling.LANCZOS)
+                # Reduce the image by 10px
+
+                enhancer = ImageEnhance.Brightness(input)
+                input = enhancer.enhance(2)
+                # Light it up a bit
+
+                background.paste(input, (5, 5))
+                # Center the image
+
+                return (background, frame_hash)
+            else:
+                return (input, frame_hash)
+        return (None, frame_hash)

streamdeck_ui/display/pipeline.py

@@ -0,0 +1,74 @@
+from fractions import Fraction
+from typing import Dict, List, Optional, Tuple
+
+from PIL.Image import Image
+
+from streamdeck_ui.display.filter import Filter
+
+
+class Pipeline:
+    def __init__(self) -> None:
+        self.filters: List[Tuple[Filter, Optional[Image]]] = []
+        self.first_run = True
+        self.output_cache: Dict[int, Image] = {}
+
+    def add(self, filter: Filter) -> None:
+        self.filters.append((filter, None))
+        self.first_run = True
+
+    def execute(self, time: Fraction) -> Optional[Tuple[Image, int]]:
+        """
+        Executes all the filter in the pipeline and returns the final image, or None if the pipeline did not yield any changes.
+        """
+
+        image: Optional[Image] = None
+        is_modified = False
+        pipeline_hash = 0
+
+        # To avoid flake8 B023 (https://docs.python-guide.org/writing/gotchas/#late-binding-closures), we need to
+        # capture the variable going into the lambda. However, as a result of that, we have a lambda that
+        # technically takes an argument (with a default) that does not match the signature we declared
+        # for the transform() method. There are likely other solutions to avoid the warning this produces,
+        # like using functools.partial, but this needs to be investigated.
+
+        for i, (current_filter, cached) in enumerate(self.filters):
+            (result_image, hashcode) = current_filter.transform(
+                lambda input_image=image: input_image.copy() if input_image else None,  # type: ignore [misc]
+                lambda output_hash, pipeline_hash=pipeline_hash: self.output_cache.get(hash((output_hash, pipeline_hash)), None),  # type: ignore [misc]
+                is_modified | self.first_run,
+                time,
+            )
+
+            pipeline_hash = hash((hashcode, pipeline_hash))
+
+            if not result_image:
+                # Filter indicated that it did NOT change anything, pull up the last
+                # cached value for the next step in the pipeline
+                image = cached
+            else:
+                # The filter changed the image, cache it for future use
+                image = result_image
+                # Update tuple with cached image
+                self.filters[i] = (current_filter, image)
+                is_modified = True
+
+            # Store this image with pipeline hash if we haven't seen it.
+            if pipeline_hash not in self.output_cache and image is not None:
+                self.output_cache[pipeline_hash] = image
+
+        if self.first_run:
+            # Force an update the first time the pipeline runs
+            is_modified = True
+            self.first_run = False
+
+        if image is not None:
+            return (image, pipeline_hash)
+        return None
+
+    def last_result(self) -> Optional[Image]:
+        """
+        Returns the last known output of the pipeline
+        """
+        if not self.filters:
+            return None
+        return self.filters[-1][1]

streamdeck_ui/display/pulse_filter.py

@@ -0,0 +1,54 @@
+from fractions import Fraction
+from typing import Callable, Optional, Tuple
+
+from PIL import Image, ImageEnhance
+
+from streamdeck_ui.display.filter import Filter
+
+
+class PulseFilter(Filter):
+    last_time: Fraction
+    pulse_delay: float
+    brightness: float
+    dim_brightness: float
+    filter_hash: int
+
+    def __init__(self):
+        super(PulseFilter, self).__init__()
+        self.last_time = Fraction()
+        self.pulse_delay = 0.5
+        self.brightness = 1
+        self.dim_brightness = 0.5
+        self.filter_hash = hash(self.__class__)
+
+    def initialize(self, size: Tuple[int, int]):
+        pass
+
+    def transform(  # type: ignore[override]
+        self,
+        get_input: Callable[[], Image.Image],
+        get_output: Callable[[int], Image.Image],
+        input_changed: bool,
+        time: Fraction,
+    ) -> Tuple[Optional[Image.Image], int]:
+        brightness_changed = False
+        if time - self.last_time > self.pulse_delay:
+            brightness_changed = True
+            self.last_time = time
+
+            if self.brightness == self.dim_brightness:
+                self.brightness = 1
+            else:
+                self.brightness = self.dim_brightness
+
+        frame_hash = hash((self.filter_hash, self.brightness))
+        if input_changed or brightness_changed:
+            image = get_output(frame_hash)
+            if image:
+                return (image, frame_hash)
+
+            input = get_input()
+            enhancer = ImageEnhance.Brightness(input)
+            input = enhancer.enhance(self.brightness)
+            return (input, frame_hash)
+        return (None, frame_hash)

streamdeck_ui/display/text_filter.py

@@ -0,0 +1,142 @@
+from fractions import Fraction
+from typing import Callable, Optional, Tuple
+
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+
+from streamdeck_ui.config import DEFAULT_FONT_FALLBACK_PATH
+from streamdeck_ui.display.filter import Filter
+
+
+class TextFilter(Filter):
+    font_blur: Optional[ImageFilter.Kernel] = None
+    # Static instance - no need to create one per Filter instance
+
+    image: Optional[Image.Image]
+
+    def __init__(
+        self, text: str, font: str, font_size: int, font_color: str, vertical_align: str, horizontal_align: str
+    ):
+        super(TextFilter, self).__init__()
+        self.text = text
+        self.vertical_align = vertical_align
+        self.horizontal_align = horizontal_align
+        self.font_color = font_color
+        self.fallback_font = ImageFont.truetype(DEFAULT_FONT_FALLBACK_PATH, font_size)
+        try:
+            self.true_font = ImageFont.truetype(font, font_size)
+        except OSError:
+            print("Unable to set font: " + font)
+            self.true_font = self.fallback_font
+        # fmt: off
+        kernel = [
+            0, 1, 2, 1, 0,
+            1, 2, 4, 2, 1,
+            2, 4, 8, 4, 1,
+            1, 2, 4, 2, 1,
+            0, 1, 2, 1, 0]
+        # fmt: on
+        TextFilter.font_blur = ImageFilter.Kernel((5, 5), kernel, scale=0.1 * sum(kernel))
+        self.offset = 0.0
+        self.offset_direction = 1
+        self.image = None
+
+        # Hashcode should be created for anything that makes this frame unique
+        self.hashcode = hash((self.__class__, text, font, font_size, font_color, vertical_align, horizontal_align))
+
+    def initialize(self, size: Tuple[int, int]):
+        self.image = Image.new("RGBA", size)
+        foreground_draw = ImageDraw.Draw(self.image)
+        # Split the text by newline to determine label height
+        # then grab the longest word to determine label width
+        text_split_newline = sorted(self.text.split("\n"), key=len)
+        # Calculate the height and width of the text we're drawing, using the font itself
+        # Previously we counted the number of characters to determine the width, but if the font wasn't a fixed width
+        # the horizontal alignment would be off.
+        _, _, label_w, _ = foreground_draw.textbbox((0, 0), self.text, font=self.true_font)
+        # Calculate dimensions for text that include ascender (above the line)
+        # and below the line  (descender) characters. This is used to adjust the
+        # font placement and should allow for button text to horizontally align
+        # across buttons. Basically we want to figure out what is the tallest
+        # text we will need to draw.
+        _, _, _, label_h = foreground_draw.textbbox(
+            (0, 0), "\n".join(["lLpgyL|"] * len(text_split_newline)), font=self.true_font
+        )
+
+        gap = (size[1] - 5 * label_h) // 4
+
+        if self.vertical_align == "top":
+            label_y = 0
+        elif self.vertical_align == "middle-top":
+            label_y = int(gap + label_h)
+        elif self.vertical_align == "middle":
+            label_y = size[1] // 2 - (int(label_h) // 2)
+        elif self.vertical_align == "middle-bottom":
+            label_y = int((gap + label_h) * 3)
+        else:
+            label_y = int(size[1] - label_h)
+            # Default or "bottom"
+
+        if self.horizontal_align == "left":
+            label_x = 0
+        elif self.horizontal_align == "right":
+            label_x = int(size[0] - label_w)
+        else:
+            self.horizontal_align = "center"
+            label_x = (size[0] - int(label_w)) // 2
+            # Default or "center"
+
+        label_pos = (label_x, label_y)
+
+        try:
+            foreground_draw.multiline_text(
+                label_pos,
+                text=self.text,
+                font=self.true_font,
+                fill=self.font_color,
+                align=self.horizontal_align,
+                spacing=0,
+                stroke_fill="black",
+                stroke_width=2,
+            )
+        except OSError:
+            print("Font does not render with pillow, falling back to default font.")
+            foreground_draw.multiline_text(
+                label_pos,
+                text=self.text,
+                font=self.fallback_font,
+                fill=self.font_color,
+                align=self.horizontal_align,
+                spacing=0,
+                stroke_fill="black",
+                stroke_width=2,
+            )
+
+    def transform(  # type: ignore[override]
+        self,
+        get_input: Callable[[], Image.Image],
+        get_output: Callable[[int], Image.Image],
+        input_changed: bool,
+        time: Fraction,
+    ) -> Tuple[Optional[Image.Image], int]:
+        """
+        The transformation returns the loaded image, ando overwrites whatever came before.
+        """
+
+        if input_changed:
+            image = get_output(self.hashcode)
+            if image:
+                return (image, self.hashcode)
+
+            input = get_input()
+            if self.image:
+                input.paste(self.image, self.image)
+            return (input, self.hashcode)
+        return (None, self.hashcode)
+
+
+def is_a_valid_text_filter_font(font) -> bool:
+    try:
+        TextFilter("", font, 12, "white", "top", "left")
+        return True
+    except BaseException:  # noqa: B036
+        return False