PlayPy 0.2.1__py3-none-any.whl

playpy/elements.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TypeGuard, TypeVar, TYPE_CHECKING
+
+import pygame as pg
+
+from .state import FRect, Rect
+from . import resources
+
+if TYPE_CHECKING:
+    from .workspace import Workspace
+
+_T = TypeVar("_T", bound="UIModifier")
+
+class UIModifier:
+    def __init__(self) -> None:
+        resources.require_init()
+        self._parent: "UIElement | None" = None
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @parent.setter
+    def parent(self, value: "UIElement | None"):
+        if value is self._parent:
+            return
+
+        # Detach from existing parent, if still registered there.
+        if self._parent is not None:
+            current = self._parent._modifiers.get(type(self))
+            if current is self:
+                del self._parent._modifiers[type(self)]
+
+        self._parent = value
+
+        # Attach to new parent, replacing existing modifier of same type.
+        if value is not None:
+            existing = value._modifiers.get(type(self))
+            if existing is not None and existing is not self:
+                existing._parent = None
+            value._modifiers[type(self)] = self
+
+    @parent.deleter
+    def parent(self):
+        self.parent = None
+
+class UIElement(ABC):
+    def __init__(
+        self,
+        scale: FRect,
+        offset: Rect,
+        visible: bool = True,
+        enabled: bool = True,
+        z: int = 0,
+    ):
+        resources.require_init()
+        self._children: list[UIElement] = []
+        self._parent: "UIElement | Workspace | None" = None
+        self.scale = scale
+        self.offset = offset
+        self.enabled = enabled
+        self._visible = visible
+        self.z = z
+        self._modifiers: dict[type[UIModifier], UIModifier] = {}
+        self.block_input_when_occluded = True
+
+    @property
+    def visible(self):
+        if not isinstance(self._parent, UIElement):
+            return self._visible
+        return self._visible and self._parent.visible
+
+    @property
+    def parent(self) -> "UIElement | Workspace | None":
+        return self._parent
+
+    @parent.setter
+    def parent(self, value: "UIElement | Workspace | None"):
+        if self._parent is not None:
+            self._parent._children.remove(self)
+        self._parent = value
+        if value is not None:
+            value._children.append(self)
+
+    @property
+    def ancestors(self) -> "list[Workspace | UIElement]":
+        if self.parent is None:
+            return []
+        elif isinstance(self.parent, Workspace):
+            return [self.parent]
+        else:
+            return self.parent.ancestors + [self.parent]
+
+    @property
+    def children(self) -> list["UIElement"]:
+        return self._children
+    
+    @property
+    def descendants(self) -> list["UIElement"]:
+        descendants: list[UIElement] = []
+        for child in self._children:
+            descendants.append(child)
+            descendants.extend(child.descendants)
+        return descendants
+
+    def add_child(self, child: "UIElement", z: int | None = None) -> None:
+        if z is not None:
+            child.z = z
+        child.parent = self
+
+    def remove_child(self, child: "UIElement") -> None:
+        child.parent = None
+
+    def set_modifier(self, modifier: UIModifier) -> None:
+        modifier.parent = self
+
+    def get_modifier(self, mod_type: type[_T]) -> _T | None:
+        return self._modifiers.get(mod_type)  # type: ignore
+
+    def remove_modifier(self, mod_type: type) -> None:
+        if mod_type in self._modifiers:
+            self._modifiers[mod_type].parent = None
+
+    @abstractmethod
+    def draw(self, workspace: "Workspace"): ...
+
+    @abstractmethod
+    def handle_input(self, workspace: "Workspace"): ...
+
+    def get_rect_px(self, workspace: "Workspace") -> pg.Rect:
+        return workspace.get_element_rect(self)
+
+    def is_mouse_over(self, workspace: "Workspace") -> bool:
+        return workspace.is_mouse_over(self)
+
+    def is_mouse_top(self, workspace: "Workspace") -> bool:
+        return workspace.is_mouse_top(self)
+    
+    def is_descendant_of(self, ancestor: "UIElement | Workspace") -> bool:
+        current = self._parent
+        while current is not None:
+            if current is ancestor:
+                return True
+            if not isinstance(current, UIElement):
+                break
+            current = current._parent
+        return False
+
+    def is_ancestor_of(self, descendant: "UIElement") -> bool:
+        return descendant.is_descendant_of(self)
+
+    def is_parent_of(self, child: "UIElement") -> bool:
+        return child._parent is self
+    
+    def is_child_of(self, parent: "UIElement"):
+        return parent.is_parent_of(self)
+    
+    def destroy(self):
+        self.parent = None
+        for child in self.children:
+            child.destroy()
+
+class Scene(UIElement):
+    def __init__(
+        self,
+        scale: FRect | None = None,
+        offset: Rect | None = None,
+        visible: bool = True,
+        enabled: bool = True,
+        z: int = 0,
+        name: str | None = None,
+    ):
+        if scale is None:
+            scale = FRect(0, 0, 1, 1)
+        if offset is None:
+            offset = Rect(0, 0, 0, 0)
+        super().__init__(scale, offset, visible=visible, enabled=enabled, z=z)
+        self.name = name
+
+    def on_enter(self, workspace: "Workspace"):
+        pass
+
+    def on_exit(self, workspace: "Workspace"):
+        pass
+
+    def on_pause(self, workspace: "Workspace"):
+        pass
+
+    def on_resume(self, workspace: "Workspace"):
+        pass
+
+    def draw(self, workspace: "Workspace"):
+        pass
+
+    def handle_input(self, workspace: "Workspace"):
+        pass
+
+
+__all__ = [
+    "UIModifier",
+    "UIElement",
+    "Scene",
+]

playpy/resources.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import os
+import tomllib
+
+os.environ["PYGAME_HIDE_SUPPORT_PROMPT"] = "1"
+
+import inspect
+import sys
+from pathlib import Path
+from enum import Enum, auto
+
+import pygame as pg
+import colorama as clr
+
+clr.init()
+
+__version__ = "0.2.1"
+
+DATA_DIR = Path(__file__).resolve().parent / "data"
+DEFAULT_ICON_PATH = DATA_DIR / "default_icon.ppm"
+
+_init_message = (
+    clr.Style.BRIGHT + f"Hello from PlayPy! (V{__version__})\n" +
+    clr.Style.DIM + f"Pygame V{pg.ver}\n" +
+    clr.Style.NORMAL + clr.Fore.YELLOW + "[WARNING]: This package is a beta. Things will be changed, and bugs might appear.\n" +
+    clr.Style.RESET_ALL + "PlayPy is a lightweight Python library for creating simple games and interactive applications with ease. It provides a straightforward API for handling graphics, input, and basic game mechanics, making it ideal for beginners and those looking to quickly prototype their ideas."
+)
+
+_initialized = False
+_debug = False
+
+def enter_debug_mode():
+    if _initialized:
+        log(Severity.ERROR, InitializationError, 'Please use "enter_debug_mode" before all other methods as it cannot be used after initialization.')
+    _debug = True
+
+def init():
+    global _initialized
+    if not _initialized:
+        pg.init()
+        _initialized = True
+        if _init_message:
+            print(_init_message)
+
+def require_init():
+    if not _initialized:
+        log(Severity.WARNING, InitializationWarning, "Please call the `plp.init()` function before doing anything else in this module.")
+        init()
+
+class Log: pass
+
+class LogWarning(Log): pass
+
+class LogError(Log): pass
+
+class InitializationError(LogError): pass
+
+class InitializationWarning(LogWarning): pass
+
+class InvalidDirectory(LogError): pass
+
+class InvalidValue(LogError): pass
+
+class Severity(Enum):
+    INFO = auto()
+    WARNING = auto()
+    ERROR = auto()
+    CRITICAL = auto()
+
+sev_color: dict[Severity, str] = {
+    Severity.INFO: clr.Fore.BLUE,
+    Severity.WARNING: clr.Fore.YELLOW,
+    Severity.ERROR: clr.Fore.RED,
+    Severity.CRITICAL: clr.Style.BRIGHT + clr.Fore.RED
+}
+
+sev_stack_size: dict[Severity, int | None] = {
+    Severity.INFO: 0,
+    Severity.WARNING: 3,
+    Severity.ERROR: 5,
+    Severity.CRITICAL: None
+}
+
+no_stack_error_type = InvalidDirectory
+
+def no_stack_error(log_category: type[Log]):
+    print(
+        f"{sev_color[Severity.CRITICAL]}[CRITICAL]: <Location not found>\n" +
+        f"  [{no_stack_error_type.__name__}]: Could not print [{log_category.__name__}] log as the current stack was not found.{clr.Style.RESET_ALL}"
+    )
+    sys.exit(1)
+
+def log(severity: Severity, category: type[Log], message: str):
+    full_msg: str = ""
+
+    current_frame = inspect.currentframe()
+    if not current_frame:
+        no_stack_error(category)
+        return
+    current_frame = current_frame.f_back
+    if not current_frame:
+        no_stack_error(category)
+        return
+    
+    warn_info = inspect.getframeinfo(current_frame)
+
+    full_msg += f"{sev_color[severity]}[{severity.name}] In {warn_info.filename}, line {warn_info.lineno}\n"
+
+    if severity != Severity.CRITICAL:
+        full_msg += clr.Style.RESET_ALL
+
+    full_msg += f"  [{category.__name__}]: {message}\n"
+
+    full_msg += clr.Style.RESET_ALL + clr.Style.DIM
+
+    current_frame = current_frame.f_back
+    stack_left = sev_stack_size[severity]
+
+    while current_frame and (stack_left is None or stack_left > 0):
+        info = inspect.getframeinfo(current_frame)
+        full_msg += f"    {info.filename}:{info.lineno}{'\n      ' + info.code_context[0].strip() if info.code_context else ''}\n"
+        current_frame = current_frame.f_back
+        if stack_left is not None:
+            stack_left -= 1
+
+    full_msg += clr.Style.RESET_ALL
+
+    print(full_msg)
+
+    if (severity == Severity.ERROR or severity == Severity.CRITICAL) and not _debug:
+        sys.exit(1)
+
+__all__ = [
+    "DATA_DIR",
+    "DEFAULT_ICON_PATH",
+    "__version__",
+    "enter_debug_mode",
+    "init",
+    "Log",
+    "LogWarning",
+    "LogError",
+    "InitializationError",
+    "InitializationWarning",
+    "Severity",
+    "log"
+]