PlayPy 0.2.1__py3-none-any.whl

playpy/workspace.py

@@ -0,0 +1,432 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pygame as pg
+
+from .elements import Scene, UIElement
+from . import resources
+from .resources import DEFAULT_ICON_PATH
+from .state import ColorValue, FRect, InputState, Key, MouseButton, Rect
+from .builtin import UIPadding, GlobalElement
+
+def init():
+    resources.init()
+    pg.init()
+
+class Workspace:
+    def __init__(
+        self,
+        windowed_width: int = 800,
+        windowed_height: int = 600,
+        color: ColorValue = (255, 255, 255),
+        fps: int = 60,
+        name: str | None = None,
+        icon: str | Path | None = None,
+    ):
+        resources.require_init()
+
+        self.windowed_size = (windowed_width, windowed_height)
+
+        info = pg.display.Info()
+        self.fullscreen_size = (info.current_w, info.current_h)
+
+        self.size = self.windowed_size
+
+        self.color = color
+        self.fps = fps
+        self.running = False
+        self.name = name
+        self.icon = icon
+
+        self._children: list[UIElement] = []
+        self._scene_stack: list[Scene] = []
+        self._modal_stack: list[UIElement] = []
+        self._hovered_set: set[UIElement] = set()
+        self._hovered_top: UIElement | None = None
+        self._last_hovered_set: set[UIElement] = set()
+        self._last_hovered_top: UIElement | None = None
+        self._scene_changed = False
+        self._modal_changed = False
+        self.last_scene_change_time = 0.0
+        self.last_modal_change_time = 0.0
+        self.scene_change_queue: list[Scene | None] = []
+        self.scene_push_queue: list[Scene | None] = [] 
+        self.modal_push_queue: list[tuple[UIElement, bool]] = []  # (modal, is_push)
+
+        self.screen = pg.display.set_mode(self.size)
+        self.clock = pg.time.Clock()
+
+        if self.name:
+            pg.display.set_caption(self.name)
+        else:
+            pg.display.set_caption("PlayPy Window")
+
+        icon_path = Path(self.icon) if self.icon is not None else DEFAULT_ICON_PATH
+        if icon_path and icon_path.exists():
+            try:
+                pg.display.set_icon(pg.image.load(str(icon_path)))
+            except Exception:
+                pass
+
+        # Input tracking
+        self.input = InputState()
+
+    @property
+    def children(self) -> list[UIElement]:
+        return self._children
+
+    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
+
+    @property
+    def current_scene(self) -> Scene | None:
+        if not self._scene_stack:
+            return None
+        return self._scene_stack[-1]
+
+    @property
+    def scene_changed(self) -> bool:
+        return self._scene_changed
+    
+    @property
+    def current_modal(self) -> UIElement | None:
+        if not self._modal_stack:
+            return None
+        return self._modal_stack[-1]
+
+    @property
+    def modal_changed(self) -> bool:
+        return self._modal_changed
+    
+    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 _record_scene_change(self, old_scene: Scene | None, new_scene: Scene | None) -> None:
+        if old_scene is not new_scene:
+            self.previous_scene = old_scene
+            self._scene_changed = True
+            self.last_scene_change_time = self.input.runtime
+
+    def _record_modal_change(self, old_modal: UIElement | None, new_modal: UIElement | None) -> None:
+        if old_modal is not new_modal:
+            self.previous_modal = old_modal
+            self._modal_changed = True
+            self.last_modal_change_time = self.input.runtime
+
+    def _resolve_queued_scene_change(self):
+        if not self._scene_changed:
+            return
+        old_scene = self.current_scene
+        while self._scene_stack:
+            old = self._scene_stack.pop()
+            try:
+                old.on_exit(self)
+            finally:
+                self.remove_child(old)
+        if self.scene_change_queue:
+            scene = self.scene_change_queue.pop(0)
+        else:
+            scene = None
+        if scene is None:
+            self._record_scene_change(old_scene, None)
+            return
+        self._scene_stack.append(scene)
+        scene.parent = self
+        scene.on_enter(self)
+        self._record_scene_change(old_scene, scene)
+
+    def queue_scene_change(self, scene: Scene | None) -> None:
+        self.scene_change_queue.append(scene)
+        self._scene_changed = True
+
+    def _resolve_queued_scene_push(self):
+        while self.scene_push_queue:
+            scene = self.scene_push_queue.pop(0)
+            if scene is None:
+                if not self._scene_stack:
+                    continue
+                popped = self._scene_stack.pop()
+                try:
+                    popped.on_exit(self)
+                finally:
+                    self.remove_child(popped)
+                current = self.current_scene
+                if current is not None:
+                    current.on_resume(self)
+                self._record_scene_change(popped, current)
+            else:
+                current = self.current_scene
+                if current is not None:
+                    current.on_pause(self)
+                self._scene_stack.append(scene)
+                scene.parent = self
+                scene.on_enter(self)
+                self._record_scene_change(current, scene)
+
+    def queue_scene_push(self, scene: Scene) -> None:
+        self.scene_push_queue.append(scene)
+
+    def queue_scene_pop(self) -> None:
+        self.scene_push_queue.append(None)
+
+    @property
+    def has_modal(self) -> bool:
+        return bool(self._modal_stack)
+
+    @property
+    def active_modal(self) -> UIElement | None:
+        if not self._modal_stack:
+            return None
+        return self._modal_stack[-1]
+    
+    # pushing a modal should add it to the stack, while popping it should remove it. When a modal is pushed, the old modal (if any) should have its on_pause called, and the new modal should have its on_enter called. When a modal is popped, the old modal should have its on_exit called, and the new top modal (if any) should have its on_resume called.
+    def _resolve_queued_modal_push(self):
+        while self.modal_push_queue:
+            modal, is_push = self.modal_push_queue.pop(0)
+            if is_push:
+                current = self.active_modal
+                if current is not None:
+                    pause_func = getattr(current, "on_pause", None)
+                    if callable(pause_func):
+                        pause_func(modal, self)
+                self._modal_stack.append(modal)
+                modal.parent = self
+                enter_func = getattr(modal, "on_enter", None)
+                if callable(enter_func):
+                    enter_func(modal, self)
+                self._record_modal_change(current, modal)
+            else:
+                if not self._modal_stack:
+                    continue
+                if modal in self._modal_stack:
+                    was_active = self.active_modal is modal
+                    self._modal_stack.remove(modal)
+                    try:
+                        exit_func = getattr(modal, "on_exit", None)
+                        if callable(exit_func):
+                            exit_func(modal, self)
+                    finally:
+                        self.remove_child(modal)
+                    if was_active:
+                        current = self.active_modal
+                        if current is not None:
+                            resume_func = getattr(current, "on_resume", None)
+                            if callable(resume_func):
+                                resume_func(modal, self)
+                        self._record_modal_change(modal, current)
+                else:
+                    continue
+
+    def queue_modal_push(self, modal: UIElement) -> None:
+        self.modal_push_queue.append((modal, True))
+
+    def queue_modal_pop(self, modal: UIElement) -> None:
+        self.modal_push_queue.append((modal, False))
+
+    def queue_modal_clear(self) -> None:
+        for modal in reversed(self._modal_stack):
+            self.modal_push_queue.append((modal, False))
+
+    def get_element_rect(self, element: UIElement) -> pg.Rect:
+        parent = element.parent
+        if isinstance(parent, UIElement):
+            base_rect = self.get_element_rect(parent)
+            base_x, base_y = base_rect.x, base_rect.y
+            base_w, base_h = base_rect.w, base_rect.h
+            if getattr(parent, "scrollable", False):
+                base_y -= int(getattr(parent, "scroll_y", 0))
+        else:
+            base_x, base_y = 0, 0
+            base_w, base_h = self.size
+
+        padding = element.get_modifier(UIPadding)
+
+        if padding:
+            pad_scale = padding.scale
+            pad_offset = padding.offset
+        else:
+            pad_scale = 0.0
+            pad_offset = 0
+
+        rect_x = max(round((element.scale.x + pad_scale) * base_w) + element.offset.x + pad_offset + base_x, 0)
+        rect_y = max(round((element.scale.y + pad_scale) * base_h) + element.offset.y + pad_offset + base_y, 0)
+        rect_w = max(round((element.scale.w - 2 * pad_scale) * base_w) + element.offset.w - 2 * pad_offset, 0)
+        rect_h = max(round((element.scale.h - 2 * pad_scale) * base_h) + element.offset.h - 2 * pad_offset, 0)
+        return pg.Rect(rect_x, rect_y, rect_w, rect_h)
+
+    def _clips_descendants(self, element: UIElement) -> bool:
+        return isinstance(element, Scene) or getattr(element, "scrollable", False)
+
+    def _clip_for_element(self, element: UIElement) -> pg.Rect | None:
+        clip: pg.Rect | None = None
+        parent = element.parent
+        while isinstance(parent, UIElement):
+            if self._clips_descendants(parent):
+                rect = self.get_element_rect(parent)
+                clip = rect if clip is None else clip.clip(rect) 
+            parent = parent.parent
+        return clip
+
+    def _point_within_clip_ancestors(self, element: UIElement, point: tuple[int, int]) -> bool:
+        parent = element.parent
+        while isinstance(parent, UIElement):
+            if self._clips_descendants(parent):
+                if not self.get_element_rect(parent).collidepoint(point):
+                    return False
+            parent = parent.parent
+        return True
+
+    def update_input(self):
+        self.input.text_input = []
+        self.input.mouse_wheel = 0
+        for event in pg.event.get():
+            if event.type == pg.QUIT:
+                self.input.quit = True
+            else:
+                self.input.quit = False
+
+            if event.type == pg.KEYDOWN:
+                self.input.keys_pressed.add(Key.from_pygame(event.key))
+            elif event.type == pg.KEYUP:
+                self.input.keys_pressed.discard(Key.from_pygame(event.key))
+
+            elif event.type == pg.MOUSEBUTTONDOWN:
+                self.input.mouse_buttons_pressed.add(MouseButton.from_pygame(event.button))
+            elif event.type == pg.MOUSEBUTTONUP:
+                self.input.mouse_buttons_pressed.discard(MouseButton.from_pygame(event.button))
+
+            elif event.type == pg.MOUSEMOTION:
+                self.input.mouse_pos = event.pos
+            elif event.type == pg.TEXTINPUT:
+                if event.text:
+                    self.input.text_input.append(event.text)
+            elif event.type == pg.MOUSEWHEEL:
+                self.input.mouse_wheel += event.y
+
+    def _is_element_hittable(self, element: UIElement) -> bool:
+        if not element.visible or not element.enabled:
+            return False
+        rect = element.get_rect_px(self)
+        if rect.w <= 0 or rect.h <= 0:
+            return False
+        if not rect.collidepoint(self.input.mouse_pos):
+            return False
+        return self._point_within_clip_ancestors(element, self.input.mouse_pos)
+
+    def _update_hover_state(self, draw_order: list[UIElement]) -> None:
+        self._last_hovered_set = self._hovered_set
+        self._last_hovered_top = self._hovered_top
+
+        hovered: list[UIElement] = []
+        for element in draw_order:
+            if self._is_element_hittable(element):
+                hovered.append(element)
+        self._hovered_set = set(hovered)
+        self._hovered_top = hovered[-1] if hovered else None
+
+    def generate_processing_order(self, target: UIElement | None = None):
+        order: list[UIElement] = []
+        if target is None:
+            targ = self
+        else:
+            targ = target
+            order.append(targ)
+
+        for child in sorted(targ._children, key=lambda x: x.z):
+            order.extend(self.generate_processing_order(child))
+        return order
+    
+    def generate_global_processing_order(self) -> list[UIElement]:
+        # Generate processing order for elements that are in the workspace but not in the current scene, AND have the global modifier
+        order: list[UIElement] = []
+        for child in sorted(self._children, key=lambda x: x.z):
+            if child not in self._scene_stack and child.get_modifier(GlobalElement):
+                order.append(child)
+                order.extend(self.generate_processing_order(child))
+        return order
+
+    def _base_processing_order(self) -> list[UIElement]:
+        scene = self.current_scene
+        if scene is not None:
+            return self.generate_processing_order(scene) + self.generate_global_processing_order()
+        return self.generate_processing_order()
+
+    def is_mouse_over(self, element: UIElement) -> bool:
+        return element in self._hovered_set
+
+    def is_mouse_top(self, element: UIElement) -> bool:
+        return self._hovered_top is element
+
+    def just_hovered_inclusive(self, element: UIElement) -> bool:
+        return element in self._hovered_set and element not in self._last_hovered_set
+
+    def just_hovered(self, element: UIElement) -> bool:
+        return self._hovered_top is element and self._last_hovered_top is not element
+
+    def just_unhovered_inclusive(self, element: UIElement) -> bool:
+        return element not in self._hovered_set and element in self._last_hovered_set
+
+    def just_unhovered(self, element: UIElement) -> bool:
+        return self._hovered_top is not element and self._last_hovered_top is element
+
+    def run(self):
+        self.running = True
+        while self.running:
+            self.screen.fill(self.color)
+
+            base_order = self._base_processing_order()
+            modal = self.active_modal
+            if modal is not None:
+                modal_order = self.generate_processing_order(modal)
+            else:
+                modal_order = []
+            self.update_input()
+
+            self._resolve_queued_scene_change()
+            self._resolve_queued_scene_push()
+            self._resolve_queued_modal_push()
+
+            input_order = modal_order if modal_order else base_order
+            self._update_hover_state(base_order + modal_order)
+            for inp_target in reversed(input_order):
+                if (
+                    inp_target.block_input_when_occluded
+                    and self.is_mouse_over(inp_target)
+                    and not self.is_mouse_top(inp_target)
+                ):
+                    continue
+                inp_target.handle_input(self)
+
+            for draw_target in [*base_order, *modal_order]:
+                clip = self._clip_for_element(draw_target)
+                if clip is not None:
+                    prev_clip = self.screen.get_clip()
+                    self.screen.set_clip(clip)
+                    draw_target.draw(self)
+                    self.screen.set_clip(prev_clip)
+                else:
+                    draw_target.draw(self)
+
+            pg.display.flip()
+            self.input.next_frame(self.clock.tick(self.fps) / 1000)
+            self._scene_changed = False
+            self._modal_changed = False
+        pg.quit()
+
+    def quit(self):
+        self.running = False
+        self.input.quit = True
+
+__all__ = [
+    "init",
+    "Workspace"
+]

playpy-0.2.1.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: PlayPy
+Version: 0.2.1
+Summary: 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.
+Author-email: angel <angyv2861@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Angel Ventura
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame-ce>=2.5.6
+Requires-Dist: colorama>=0.4.6
+Dynamic: license-file
+
+# PlayPy (0.2.1)
+
+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.
+
+## Requirements
+
+- Python `>=3.11`
+- `pygame >=2.6.1`
+
+## Installation
+
+To install PlayPy, enter the following line into your terminal: `pip install playpy`, or `python -m pip install playpy` if the first line does not work.
+
+## Core Concepts
+
+### Workspace
+
+`Workspace` owns the window, render loop, input state, scene stack, and modal stack.
+
+Key methods:
+
+- `run()` starts runtime loop
+- `quit()` stops runtime loop
+- `queue_scene_change(scene)` replaces the current scene
+- `queue_scene_push(scene)` / `queue_scene_pop()` stacks scenes
+- `queue_modal_push(element)` / `queue_modal_pop()` manages overlays
+
+### Layout Values
+
+PlayPy uses two rectangle value types:
+
+- `FRect(*args)`
+  Relative scale (fraction of parent rectangle).
+- `Rect(*args)`
+  Absolute pixel offsets applied on top of scale.
+- Overloads are: `x, y, w, h` \ `topleft, size` \ `(x, y, w, h)` \ `(topleft, size)`
+
+Final element rect = `scale * parent_size + offset`.
+
+### Parenting
+
+Any `UIElement` can contain children. Assigning parent wires it automatically:
+
+```python
+child.parent = parent
+```
+
+Or use helpers:
+
+```python
+parent.add_child(child)
+```
+
+You can use the `parent`, `ancestors`, `children`, and `descendants` properties to find ancestors or descendants of an element.
+
+You can use other built-in methods to tell descendance:
+- `is_parent_of(child)`, `is_child_of(parent)`
+- `is_ancestor_of(descendant)`, `is_descendant_of(ancestor)`
+
+## Built-in Elements
+
+- `UIPanel`: colored rectangle container
+- `UIScrollablePanel`: panel with wheel scrolling
+- `UIText`: wrapped text rendering with alignment
+- `UIButton`: clickable button with hover/pressed colors
+- `UITextbox`: single-line text input with placeholder/caret
+- `Scene`: root container for scene lifecycle
+
+## Modifiers
+
+Modifiers attach style/behavior to a single element.
+
+- `UIPadding(scale=0, offset=10)` - Adds padding to the element.
+- `UIOutline(color, width, edge_type)` - Adds an outline to the element.
+- `UIBorderRadius(radius)` - Adds a border radius (rounded corners) to the element.
+- `UIGradient(start_color, end_color, direction)` - Converts the background color of the element to a gradient.
+- `UIFont(font_path=None, font_size=None, bold=None, italic=None, antialias=None)` - Changes the font of the text.
+- `GlobalElement()` - If added to a `Workspace` descended element, makes this object shown and handled even when another scene is running.
+
+Attach/get/remove:
+
+```python
+element.set_modifier(plp.UIOutline((0, 0, 0), 2, "middle"))
+outline = element.get_modifier(plp.UIOutline)
+element.remove_modifier(plp.UIOutline)
+```
+
+## Event Helpers
+
+Decorator helpers create `Event` elements attached to a workspace, scene, or element.
+
+- `@on_start(target)` - Runs when the scene/workspace starts running/
+- `@on_update(target)`
+- `@on_quit(target)`
+- `@on_scene_change(target)`
+- `@on_modal_change(target)`
+- `@create_event(target, condition)` for custom conditions
+
+Events created on the main workspace will trigger in all scenes. Pass in `global_event=false` to disable this.
+
+Example:
+
+```python
+@plp.on_update(ws)
+def tick(w: plp.Workspace):
+    if plp.Key.ESCAPE in w.input.key_downs:
+        w.quit()
+
+@plp.on_update(ws, global_event=false)
+def tick(w: plp.Workspace):
+    if plp.Key.UP in w.input.key_downs:
+        w.push_scene(s)
+```
+
+## Scene and Modal Behavior
+
+- If a modal is active, input is only routed to the modal tree
+- Scene descendants are clipped to the scene rectangle for both drawing and hit-testing
+- `Workspace` tracks scene/modal transitions with:
+  - `current_scene`, `previous_scene`, `scene_changed`
+  - `current_modal`, `previous_modal`, `modal_changed`
+- Scenes can implement lifecycle hooks:
+  - `on_enter`, `on_exit`, `on_pause`, `on_resume`
+
+## Input State
+
+Read per-frame input from `workspace.input`:
+
+- `keys_pressed`, `key_downs`, `key_ups` contain `plp.Key` values
+- `mouse_buttons_pressed`, `mouse_downs`, `mouse_ups` contain `plp.MouseButton` values
+- `mouse_pos`, `mouse_delta`, `mouse_wheel`
+- `text_input`
+- `dt`, `runtime`, `quit`
+- `key_held(key)`, `key_up(key)`, `key_down(key)`
+- `mousebutton_held(mb)`, `mousebutton_up(mb)`, `mousebutton_down(mb)`
+
+### Hover State
+
+You can check the hovered objects and top hovered object using the helper methods in `Workspace`.
+
+- `is_mouse_top(element)`, `just_hovered(element)`, `just_unhovered(element)` are for checking only the top hovered object.
+- `is_mouse_over(element)`, `just_hovered_inclusive(element)`, `just_unhovered_inclusive(element)` are for checking all of the hovered objects.
+
+event helpers come with these too.
+
+- `@on_hover(scope, hovered)`, `@on_unhover(scope, hovered)`, `while_hovered(scope, hovered)` for only top.
+- `@on_hover_inclusive(scope, hovered)`, `@on_unhover_inclusive(scope, hovered)`, `while_hovered_inclusive(scope, hovered)` for all.
+
+These are useful because they can then be used to check if the user is clicking an object
+
+```python
+obj = plp.UIPanel(plp.FRect(1, 1, 0, 0), plp.empty_rect(), (0, 0, 0))
+
+@while_hovered(ws, obj)
+def click_check(w: plp.Workspace):
+    if w.input.mousebutton_down(plp.MouseButton.LEFT):
+        print("LMB down!")
+```

playpy-0.2.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+playpy/__init__.py,sha256=uWWOAXZGnk-h19MM8cxHBMqCbzI1A-52oB9k9uIyKfM,6539
+playpy/builtin.py,sha256=i1c-3iHfBHEuaIzcFwm2TiFbTi9a1z2zTrNYN1T2_Oc,22206
+playpy/elements.py,sha256=wKC5aCvHWSdyLBgUzjisx2_zKFDu2lL7zV5sya9qXB8,5777
+playpy/resources.py,sha256=Xq5t_SIviZL-hk45pvzyH23IEvkIAhaZCBQCkUO_HeU,4258
+playpy/state.py,sha256=lyK4NdSoW2wf_i15B0taSzkCZDRjo8f9ZSZjzRlwA2w,15609
+playpy/workspace.py,sha256=vVv7FvrMVKbzq0z1bAsVlignazLmBsE8O4DzeApb-7Q,16261
+playpy/data/default_icon.ppm,sha256=-NEiMj1mprrnvgQNJU8CWoOwCEO5r4pXRA7VOn68Occ,49
+playpy-0.2.1.dist-info/licenses/LICENSE,sha256=8dZpItcQjCSUQRQPqIygCC-yEEMY7RyXdqfrEuzspb0,1089
+playpy-0.2.1.dist-info/METADATA,sha256=q5dSN2qL4-y3YIF5vuvkq3e3PUYVx1TGeIXsVk4PzYk,7413
+playpy-0.2.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+playpy-0.2.1.dist-info/top_level.txt,sha256=h_sU-O668sv_ikUtp4aFsgr4XO_3AWP1XKyWcTxqqRE,7
+playpy-0.2.1.dist-info/RECORD,,

playpy-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

playpy-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Angel Ventura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

playpy-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+playpy