Cleaned up code

Author: makermelissa

Magic_AI_Storybook/book.py

@@ -1,19 +1,23 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
 import sys
 import os
 import time
 from enum import Enum
 import pygame
 
 # Image Names
-WELCOME_IMAGE = 'welcome.png'
-BACKGROUND_IMAGE = 'paper_background.png'
-LOADING_IMAGE = 'loading.png'
-BUTTON_BACK_IMAGE = 'button_back.png'
-BUTTON_NEXT_IMAGE = 'button_next.png'
+WELCOME_IMAGE = "welcome.png"
+BACKGROUND_IMAGE = "paper_background.png"
+LOADING_IMAGE = "loading.png"
+BUTTON_BACK_IMAGE = "button_back.png"
+BUTTON_NEXT_IMAGE = "button_next.png"
 
 # Asset Paths
-IMAGES_PATH = os.path.dirname(sys.argv[0]) + 'images/'
-FONTS_PATH = os.path.dirname(sys.argv[0]) + 'fonts/'
+IMAGES_PATH = os.path.dirname(sys.argv[0]) + "images/"
+FONTS_PATH = os.path.dirname(sys.argv[0]) + "fonts/"
 
 # Font Path, Size
 TITLE_FONT = (FONTS_PATH + "lucida_black.ttf", 48)
@@ -29,22 +33,22 @@
 PARAGRAPH_DELAY = 2
 
 #   Letter by Letter
-#CHARACTER_DELAY = 0.1
-#WORD_DELAY = 0
-#SENTENCE_DELAY = 0
-#PARAGRAPH_DELAY = 0
+# CHARACTER_DELAY = 0.1
+# WORD_DELAY = 0
+# SENTENCE_DELAY = 0
+# PARAGRAPH_DELAY = 0
 
 #   Word by Word
-#CHARACTER_DELAY = 0
-#WORD_DELAY = 0.3
-#SENTENCE_DELAY = 0.5
-#PARAGRAPH_DELAY = 0
+# CHARACTER_DELAY = 0
+# WORD_DELAY = 0.3
+# SENTENCE_DELAY = 0.5
+# PARAGRAPH_DELAY = 0
 
 #   No Delays
-#CHARACTER_DELAY = 0
-#WORD_DELAY = 0
-#SENTENCE_DELAY = 0
-#PARAGRAPH_DELAY = 0
+# CHARACTER_DELAY = 0
+# WORD_DELAY = 0
+# SENTENCE_DELAY = 0
+# PARAGRAPH_DELAY = 0
 
 
 # Whitespace Settings in Pixels
@@ -55,13 +59,15 @@
 EXTRA_LINE_SPACING = 0
 PARAGRAPH_SPACING = 30
 
+
 class Position(Enum):
     TOP = 0
     CENTER = 1
     BOTTOM = 2
     LEFT = 3
     RIGHT = 4
 
+
 class Button:
     def __init__(self, x, y, image, action):
         self.x = x
@@ -72,7 +78,9 @@ def __init__(self, x, y, image, action):
         self._height = self.image.get_height()
 
     def is_in_bounds(self, x, y):
-        return self.x <= x <= self.x + self.width and self.y <= y <= self.y + self.height
+        return (
+            self.x <= x <= self.x + self.width and self.y <= y <= self.y + self.height
+        )
 
     def is_pressed(self):
         pass
@@ -85,6 +93,7 @@ def width(self):
     def height(self):
         return self._height
 
+
 class Textarea:
     def __init__(self, x, y, width, height):
         self.x = x
@@ -94,10 +103,8 @@ def __init__(self, x, y, width, height):
 
     @property
     def size(self):
-        return {
-            "width": self.width,
-            "height": self.height
-        }
+        return {"width": self.width, "height": self.height}
+
 
 class Book:
     def __init__(self, rotation=0):
@@ -113,14 +120,17 @@ def __init__(self, rotation=0):
         self.height = 0
         self.back_button = None
         self.next_button = None
+        self.textarea = None
+        self.screen = None
+        self.cursor = None
 
     def init(self):
         # Output to the LCD instead of the console
-        os.putenv('DISPLAY', ':0')
+        os.putenv("DISPLAY", ":0")
 
         # Initialize the display
         pygame.init()
-        self.screen = pygame.display.set_mode((0,0), pygame.FULLSCREEN)
+        self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
         self.width = self.screen.get_height()
         self.height = self.screen.get_width()
 
@@ -136,37 +146,40 @@ def init(self):
         # Add buttons
         back_button_image = pygame.image.load(IMAGES_PATH + BUTTON_BACK_IMAGE)
         next_button_image = pygame.image.load(IMAGES_PATH + BUTTON_NEXT_IMAGE)
-        button_spacing = (self.width - (back_button_image.get_width() + next_button_image.get_width())) // 3
-        button_ypos = self.height - PAGE_NAV_HEIGHT + (PAGE_NAV_HEIGHT - next_button_image.get_height()) // 2
+        button_spacing = (
+            self.width - (back_button_image.get_width() + next_button_image.get_width())
+        ) // 3
+        button_ypos = (
+            self.height
+            - PAGE_NAV_HEIGHT
+            + (PAGE_NAV_HEIGHT - next_button_image.get_height()) // 2
+        )
         self.back_button = Button(
-            button_spacing,
-            button_ypos,
-            back_button_image,
-            self.previous_page
+            button_spacing, button_ypos, back_button_image, self.previous_page
         )
         self.next_button = Button(
             self.width - button_spacing - next_button_image.get_width(),
             button_ypos,
             next_button_image,
-            self.next_page
+            self.next_page,
         )
 
         # Add Text Area
         self.textarea = Textarea(
             PAGE_SIDE_MARGIN,
             PAGE_TOP_MARGIN,
             self.width - PAGE_SIDE_MARGIN * 2,
-            self.height - PAGE_NAV_HEIGHT - PAGE_TOP_MARGIN - PAGE_BOTTOM_MARGIN
+            self.height - PAGE_NAV_HEIGHT - PAGE_TOP_MARGIN - PAGE_BOTTOM_MARGIN,
         )
 
         pygame.mouse.set_visible(False)
-        self.screen.fill((255,255,255))
+        self.screen.fill((255, 255, 255))
 
     def handle_events(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 raise SystemExit
-            elif event.type == pygame.MOUSEBUTTONDOWN:
+            if event.type == pygame.MOUSEBUTTONDOWN:
                 if event.button == 1:
                     # If clicked in text area and book is still rendering, skip to the end
                     print(f"Left mouse button pressed at {event.pos}")
@@ -177,35 +190,37 @@ def handle_events(self):
 
     def add_page(self, paragraph=0, word=0):
         # Add rendered page information to make flipping between them easier
-        self.pages.append({
-            "paragraph": paragraph,
-            "word": word,
-        })
+        self.pages.append(
+            {
+                "paragraph": paragraph,
+                "word": word,
+            }
+        )
 
     def load_image(self, name, filename):
         try:
             image = pygame.image.load(IMAGES_PATH + filename)
             self.images[name] = image
         except pygame.error:
-            return None
+            pass
 
     def load_font(self, name, details):
         self.fonts[name] = pygame.font.Font(details[0], details[1])
 
-    def get_position(self, object, x, y):
+    def get_position(self, obj, x, y):
         if x == Position.CENTER:
-            x = (self.width - object.get_width()) // 2
+            x = (self.width - obj.get_width()) // 2
         elif x == Position.RIGHT:
-            x = self.width - object.get_width()
+            x = self.width - obj.get_width()
         elif x == Position.LEFT:
             x = 0
         elif not isinstance(x, int):
             raise ValueError("Invalid x position")
 
         if y == Position.CENTER:
-            y = (self.height - object.get_height()) // 2
+            y = (self.height - obj.get_height()) // 2
         elif y == Position.BOTTOM:
-            y = self.height - object.get_height()
+            y = self.height - obj.get_height()
         elif y == Position.TOP:
             y = 0
         elif not isinstance(y, int):
@@ -225,22 +240,21 @@ def display_image(self, image, x=Position.CENTER, y=Position.CENTER, surface=Non
             surface.blit(buffer, (0, 0))
 
     def display_current_page(self):
-        # This will be easier if we create a surface and just rotate that before rendering it to the screen
-
         self.display_image(self.images["background"], Position.CENTER, Position.CENTER)
         pygame.display.update()
 
         # Use a cursor to keep track of where we are on the page
         # These values are relative to the text area
-        self.cursor = {
-            "x": 0,
-            "y": 0
-        }
+        self.cursor = {"x": 0, "y": 0}
 
         # Display the title
         if self.page == 0:
             title = self.render_title()
-            self.display_image(title, self.cursor["x"] + self.textarea.x, self.cursor["y"] + self.textarea.y)
+            self.display_image(
+                title,
+                self.cursor["x"] + self.textarea.x,
+                self.cursor["y"] + self.textarea.y,
+            )
             pygame.display.update()
             self.cursor["y"] += title.get_height() + PARAGRAPH_SPACING
             time.sleep(PARAGRAPH_DELAY)
@@ -249,20 +263,23 @@ def display_current_page(self):
 
         # Display the navigation buttons
         if self.page > 0:
-            self.display_image(self.back_button.image, self.back_button.x, self.back_button.y)
+            self.display_image(
+                self.back_button.image, self.back_button.x, self.back_button.y
+            )
 
         # TODO: If we are on the last page, don't display the next button
-        self.display_image(self.next_button.image, self.next_button.x, self.next_button.y)
+        self.display_image(
+            self.next_button.image, self.next_button.x, self.next_button.y
+        )
         pygame.display.update()
 
     def render_character(self, character):
         return self.fonts["text"].render(character, True, (0, 0, 0))
 
     def display_page_text(self):
-        # TODO: We need an accurate way to determine when a previous page has already been added so we don't add it again
+        # TODO: We need an accurate way to determine when a
+        # previous page has already been added so we don't add it again
 
-        # Display the paragraphs, one paragraph at a time, one word at a time until we reach the end of the line
-        # then move to the next line. Once we are at the end of the page, stop displaying paragraphs
         paragraph_number = self.pages[self.page]["paragraph"]
         word_number = self.pages[self.page]["word"]
 
@@ -272,19 +289,31 @@ def display_page_text(self):
             while word_number < len(paragraph):
                 word = paragraph[word_number]
                 # Check if there is enough space to display the word
-                if self.cursor["x"] + self.fonts["text"].size(word)[0] > self.textarea.width:
+                if (
+                    self.cursor["x"] + self.fonts["text"].size(word)[0]
+                    > self.textarea.width
+                ):
                     # If not, move to the next line
                     self.cursor["x"] = 0
-                    self.cursor["y"] += self.fonts["text"].get_height() + EXTRA_LINE_SPACING
+                    self.cursor["y"] += (
+                        self.fonts["text"].get_height() + EXTRA_LINE_SPACING
+                    )
                     # If we have reached the end of the page, stop displaying paragraphs
-                    if self.cursor["y"] + self.fonts["text"].get_height() > self.textarea.height:
+                    if (
+                        self.cursor["y"] + self.fonts["text"].get_height()
+                        > self.textarea.height
+                    ):
                         self.add_page(paragraph_number, word_number)
                         return
 
                 # Display the word one character at a time
                 for character in word:
                     character_surface = self.render_character(character)
-                    self.display_image(character_surface, self.cursor["x"] + self.textarea.x, self.cursor["y"] + self.textarea.y)
+                    self.display_image(
+                        character_surface,
+                        self.cursor["x"] + self.textarea.x,
+                        self.cursor["y"] + self.textarea.y,
+                    )
                     pygame.display.update()
                     self.cursor["x"] += character_surface.get_width() + 1
                     if character != " ":
@@ -293,7 +322,8 @@ def display_page_text(self):
                 # Advance the cursor by a spaces width
                 self.cursor["x"] += self.render_character(" ").get_width() + 1
 
-                # Look at last character only to avoid long delays on stuff like "!!!" or "?!" or "..."
+                # Look at last character only to avoid long delays on stuff
+                # like "!!!" or "?!" or "..."
                 if word[-1:] in [".", "!", "?"]:
                     time.sleep(SENTENCE_DELAY)
                 else:
@@ -308,16 +338,19 @@ def display_page_text(self):
             paragraph_number += 1
 
             # If we have reached the end of the page, stop displaying paragraphs
-            if self.cursor["y"] + self.fonts["text"].get_height() > self.textarea.height:
+            if (
+                self.cursor["y"] + self.fonts["text"].get_height()
+                > self.textarea.height
+            ):
                 self.add_page(paragraph_number, word_number)
                 return
 
     def create_transparent_buffer(self, size):
         if isinstance(size, (tuple, list)):
             (width, height) = size
         elif isinstance(size, dict):
-            width = size['width']
-            height = size['height']
+            width = size["width"]
+            height = size["height"]
         buffer = pygame.Surface((width, height), pygame.SRCALPHA, 32)
         buffer = buffer.convert_alpha()
         return buffer
@@ -331,7 +364,9 @@ def render_title(self):
         text_height = 0
         for line in lines:
             text = self.fonts["title"].render(line, True, TITLE_COLOR)
-            buffer.blit(text, (buffer.get_width() // 2 - text.get_width() // 2, text_height))
+            buffer.blit(
+                text, (buffer.get_width() // 2 - text.get_width() // 2, text_height)
+            )
             text_height += text.get_height()
 
         new_buffer = self.create_transparent_buffer((self.textarea.width, text_height))
@@ -378,4 +413,4 @@ def parse_story(self, story):
         self.add_page()
 
     # save settings
-    # load settings
+    # load settings

Magic_AI_Storybook/listener.py

@@ -1,14 +1,15 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
 from datetime import datetime, timedelta
 from queue import Queue
 
 import speech_recognition as sr
 
+
 class Listener:
-    def __init__(self,
-                 energy_threshold=1000,
-                 phrase_timeout=3.0,
-                 record_timeout=30
-                ):
+    def __init__(self, energy_threshold=1000, phrase_timeout=3.0, record_timeout=30):
         self.listener_handle = None
         self.recognizer = sr.Recognizer()
         self.recognizer.energy_threshold = energy_threshold