saltpaper 0.0.2a0__py3-none-any.whl

saltpaper/__init__.py

@@ -0,0 +1,6 @@
+from saltpaper.services import *
+from saltpaper.functions import *
+from saltpaper.worldsystem.world import World
+
+SALTPAPER_VER = "0.0.1"
+print(f"saltPAPER {SALTPAPER_VER}")

saltpaper/assets/tilemaps/test.yaml

@@ -0,0 +1,19 @@
+tiles:
+  0:
+    type: grass
+    solid: no
+  1:
+    type: yellow
+    solid: yes
+  2:
+    type: purple
+    solid: yes
+  3:
+    type: black
+    solid: no
+  4:
+    type: white
+    solid: yes
+  5: 
+    type: gay
+    solid: no

saltpaper/functions/__init__.py

@@ -0,0 +1,2 @@
+from .test import make_test_entity
+from .vectortools import VectorTools

saltpaper/functions/test.py

@@ -0,0 +1,11 @@
+from saltpaper.worldsystem.entity import Entity
+from saltpaper.worldsystem.components import Position, Sprite
+
+def make_test_entity(world, layer, x, y) -> Entity:
+    
+    ent = Entity(world)
+    position = Position(layer, x, y)
+    sprite = Sprite(asset_id="image_joker")
+    ent.add_many(position, sprite)
+
+    return ent

saltpaper/functions/vectortools.py

@@ -0,0 +1,28 @@
+import math
+
+class VectorTools:
+    """I HATE MATHEMATICS"""
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def distance_between(a:tuple[float, float], b:tuple[float, float]) -> float:
+        ax, ay = a
+        bx, by = b
+
+        xdiff = bx - ax
+        ydiff = by - ay
+
+        return math.sqrt((xdiff**2 + ydiff**2))
+        # i was worried that this would crash if given a negative number
+        # but both components are exponentiated so it can never be negative
+
+    @staticmethod
+    def lerp(a: tuple[float, float], b: tuple[float, float], progress: float = 0.5) -> tuple[float, float]:
+        ax, ay = a
+        bx, by = b
+
+        return (
+            ax + (bx - ax) * progress,
+            ay + (by - ay) * progress
+        )

saltpaper/services/__init__.py

@@ -0,0 +1,8 @@
+from .assetservice import AssetService
+from .displayservice import DisplayService
+from .layer import Layer
+from .inputservice import InputService
+from .inputservice import Event
+from .inputservice import Criteria
+from .renderservice import RenderService
+from .stateservice import StateService

saltpaper/services/assetservice.py

@@ -0,0 +1,68 @@
+import pygame
+import os
+from pathlib import Path
+
+cwd = Path.cwd()
+filetypes = {
+    "image": [".png", ".jpg", ".bmp", ".gif"],
+    "music": [".wav", ".ogg", ".mp3"],
+    "sound": [".wav", ".ogg", ".mp3"],
+    "tilesheet": [".tls"], # todo
+    "room": [".room"] #todo
+}
+
+class AssetService():
+    def __init__(self):
+        self.cache = {}
+        self.roots = []
+
+    def set_assets_folder(self, path):
+        path = Path(path)
+        self.roots.append(path)
+
+    def get_asset(self, id):
+        asset = self.cache.get(id)
+        if asset is not None:
+            return asset
+
+        kind, name = id.split("_", 1)
+        extensions = filetypes.get(kind)
+
+        if extensions is None:
+            raise ValueError(f"unknown asset type: {kind}")
+
+        searched = []
+        for root in self.roots:
+            for ext in extensions:
+                path = root / kind / f"{name}{ext}"
+                searched.append(str(path))
+                if path.exists():
+                    asset = self._load_asset(kind, path)
+                    self.cache[id] = asset
+                    return asset
+
+        print(
+            f"asset not found: '{id}' (type='{kind}', name='{name}'). "
+            f"tried locations:" + '\n'.join(searched) + "\n",
+            f"ensure the asset exists in 'game/assets' or 'engine/assets' and that the id is formatted as '<type>_<name>'."
+        )
+
+        try:
+            return self.get_asset("image_missing")
+        except FileNotFoundError:
+            raise FileNotFoundError(f"No /image/missing.png is set")
+
+    def _load_asset(self, kind, path: Path):
+        if kind == "image":
+            return pygame.image.load(path).convert_alpha()
+
+        if kind == "music":
+            pygame.mixer.music.load(path)
+            return path  # music is streamed so just return path
+
+        if kind == "sound":
+            return pygame.mixer.Sound(path)
+
+        # tilesheet etc later
+        return path
+    

saltpaper/services/displayservice.py

@@ -0,0 +1,104 @@
+import pygame
+import sys
+from statistics import mean
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from saltpaper import InputService
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+class DisplayService():
+
+    def __init__(
+            self,
+            dimensions,
+            inputservice,
+            target_frame_rate:int=120,
+            caption="saltpaper engine display",
+            vsync=True, # for testing
+            iconpath=None
+    ):
+        self.dimensions = dimensions
+        self.caption = caption
+        self.inputservice:'InputService' = inputservice
+        self.target_frame_rate = target_frame_rate
+
+        self.layers = []
+
+        self.refresh_sorting()
+
+        pygame.init()
+
+        self.funcs = []
+        iconsurf = pygame.image.load(iconpath)
+        pygame.display.set_icon(iconsurf)
+        self.display = pygame.display.set_mode(dimensions, vsync=vsync)
+
+        pygame.display.set_caption(caption)
+        self.clock = pygame.time.Clock()
+        self.delta = 1
+        self.deltas = []
+
+        self.running = True
+        self.dirty = True
+
+    def mount(self, func=None):
+        if not func: return
+        self.funcs.append(func)
+
+    def refresh_sorting(self):
+        self.layers_by_tick = sorted(self.layers, key=lambda l: l.tick_priority)
+        self.layers_by_render = sorted(self.layers, key=lambda l: l.render_priority)
+
+    def add_layer(self, layer):
+        self.layers.append(layer)
+        self.refresh_sorting()
+
+    def add_many_layers(self, layers):
+        self.layers.extend(layers)
+        self.refresh_sorting
+
+    def remove_layer(self, layer):
+        for i, item in enumerate(self.layers):
+            if item is layer:
+                self.layers.pop(i)
+                self.refresh_sorting()
+                return True
+        return False
+
+    def get_layers(self):
+        return self.layers
+
+    def tick(self):
+        if len(self.layers) == 0:
+            raise ValueError("the display service has no layers to display. make sure they are added with displayservice.add_layer(layer)")
+
+        self.events = pygame.event.get()
+        self.inputservice.tick(self.events)
+        for event in self.events:
+            if event.type == pygame.QUIT:
+                self.running = False
+
+        for layer in self.layers_by_tick:
+            if layer.ticking:
+                layer.tick(self.delta)
+
+        for layer in self.layers_by_render:
+            if not layer.visible:
+                continue
+            surf = layer.render()
+            offset = layer.offset
+            self.display.blit(surf, offset)
+            
+        for func in self.funcs:
+            func(self, self.delta)
+
+        pygame.display.flip() 
+        delta_entry = self.clock.tick(self.target_frame_rate) / 1000
+        self.deltas.append(delta_entry)
+        if len(self.deltas) > 10:
+            self.deltas.pop(0)
+        self.delta = mean(self.deltas)

saltpaper/services/inputservice.py

@@ -0,0 +1,166 @@
+
+# input mapping service
+# initialises with a mapping dict of
+# key trigger -> "event" (arbitrary string)
+# i.e. K_up
+import sys
+from pathlib import Path
+from typing import Callable
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+import pygame
+import pygame.locals as pl
+import pygame._sdl2.controller as ctrl
+
+KEY_VALUE_TO_NAME = {
+    value: name
+    for name, value in vars(pl).items()
+    if name.startswith("K_")
+}
+
+BUTTON_VALUE_TO_NAME = {
+    value: name
+    for name, value in vars(pl).items()
+    if name.startswith("CONTROLLER_BUTTON_")
+}
+
+MOUSE_VALUE_TO_NAME = {
+    1: "MOUSE_LEFT",
+    2: "MOUSE_MIDDLE",
+    3: "MOUSE_RIGHT",
+    4: "MOUSE_SCROLL_UP",
+    5: "MOUSE_SCROLL_DOWN"
+}
+
+
+EVENT_TYPES_LISTENING = {
+    pygame.KEYDOWN: "key",
+    pygame.KEYUP: "key",
+    pygame.CONTROLLERBUTTONDOWN: "button",
+    pygame.CONTROLLERBUTTONUP: "button",
+    pygame.MOUSEBUTTONDOWN: "mouse",
+    pygame.MOUSEBUTTONUP: "mouse",
+}
+
+if __name__ == "__main__":
+    with open("validevents.txt", "w") as f:
+        f.write("=== KEY EVENTS ===\n")
+        for item in KEY_VALUE_TO_NAME.values():
+            f.write(f"{item}\n")
+        f.write("=== BUTTON EVENTS ===\n")
+        for item in BUTTON_VALUE_TO_NAME.values():
+            f.write(f"{item}\n")
+        f.write("=== KEY EVENTS ===\n")
+        for item in MOUSE_VALUE_TO_NAME.values():
+            f.write(f"{item}\n")
+
+class Criteria():
+    @staticmethod
+    def on_press(f):
+        return True if f==1 else False
+    
+    @staticmethod
+    def on_held(f):
+        return True if f>0 else False
+    
+    @staticmethod
+    def on_release(f):
+        return True if f==-1 else False
+    
+    @staticmethod
+    def make_on_held_interval(x):
+        def on_held_interval(f):
+            return True if f % x == 0 else False
+        return on_held_interval
+
+class Event():
+    def __init__(self, triggers: str | list, criteria: Callable, callback: Callable, args: list = None):
+        self.triggers = triggers if isinstance(triggers, list) else [triggers]
+        self.criteria = criteria
+        self.callback = callback
+        self.args = args if args else []
+
+
+class InputService():
+    def __init__(self):
+        self.gamepad = None
+        self.input_roster = {}
+        self.events = []
+        try:
+            ctrl.init()
+        except Exception:
+            pass
+        for item in KEY_VALUE_TO_NAME.values():
+            self.input_roster[item] = 0
+        for item in BUTTON_VALUE_TO_NAME.values():
+            self.input_roster[item] = 0
+        for item in MOUSE_VALUE_TO_NAME.values():
+            self.input_roster[item] = 0
+
+    @property
+    def mouse_pos(self):
+        return pygame.mouse.get_pos()
+
+
+    def register_event(self, event: Event):
+        self.events.append(event)
+
+    def check_events(self):
+        for trigger, frames in self.input_roster.items():
+            if frames == 0:
+                continue
+            for event in self.events:
+                if trigger not in event.triggers:
+                    continue
+                if event.criteria(frames):
+                    event.callback(frames, *event.args)
+
+
+    def controllercheck(self):
+        try:
+            count = ctrl.get_count()
+        except pygame.error:
+            count = 0
+
+        if count > 0 and self.gamepad is None:
+            try:
+                self.gamepad = ctrl.Controller(0)
+            except Exception:
+                self.gamepad = None
+        elif count == 0:
+            self.gamepad = None
+
+    def tick(self, events):
+        self.controllercheck()
+        self.process_events(events)
+        self.check_events()
+        for item in self.input_roster:
+
+            if self.input_roster[item] == 0:    # never pressed
+                continue
+            if self.input_roster[item] > 0:     # positive / pressed
+                self.input_roster[item] += 1
+            elif self.input_roster[item] < 0:   # negative / unpressed after first press
+                self.input_roster[item] -= 1
+
+
+    def process_events(self, events):
+        for event in events:
+            event_type = event.type
+            if not event_type in EVENT_TYPES_LISTENING.keys():
+                continue
+            target = EVENT_TYPES_LISTENING[event.type]
+            value = event.button if target == "mouse" else getattr(event, target, None)
+            if target == "key":
+                name = KEY_VALUE_TO_NAME.get(value, "unknown")
+            elif target == "button":
+                name = BUTTON_VALUE_TO_NAME.get(value, "unknown")
+            elif target == "mouse":
+                name = MOUSE_VALUE_TO_NAME.get(value, "unknown")
+            else:
+                name = "unknown"
+            updown = -1 if event_type in [pygame.KEYUP, pygame.CONTROLLERBUTTONUP, pygame.MOUSEBUTTONUP] else 1
+            self.input_roster[name] = updown
+        

saltpaper/services/layer.py

@@ -0,0 +1,91 @@
+import pygame
+import numpy as np
+
+class Layer:
+    def __init__(
+            self,
+            dimensions,
+            render_priority=0,
+            tick_priority=0,
+            opacity_percent=100,
+            surface=None,
+    ):
+        self.dimensions = dimensions
+        self.surface = surface if surface else pygame.Surface(dimensions, pygame.HWSURFACE | pygame.SRCALPHA)
+        self.visible = True
+        self.ticking = True
+        self.opacity_percent = opacity_percent
+        self.offset = (0,0)
+        
+        self.render_priority = render_priority
+        self.tick_priority = tick_priority
+        
+        self.funcs = []
+
+        # loopscroll()
+        self._loopscroll_accum_x = 0.0
+        self._loopscroll_accum_y = 0.0
+
+    def mount(self, func=None):
+        """mount a function to be called when this layer ticks. gives the layer and delta as arguments (i.e. `main(layer, delta)`)"""
+        if not func: return
+        self.funcs.append(func)
+
+    def tick(self, delta):
+        for func in self.funcs:
+            func(self, delta)
+    
+    def render(self):
+        if self.opacity_percent >= 100:
+            return self.surface
+        
+        surf = self.surface.copy()
+        surf.set_alpha(int(self.opacity_percent * 2.55))
+        return surf
+    
+
+    def loopscroll(self, dx, dy, dt=1.0):
+        self._loopscroll_accum_x += dx * dt
+        self._loopscroll_accum_y += dy * dt
+
+        scroll_x = int(self._loopscroll_accum_x)
+        scroll_y = int(self._loopscroll_accum_y)
+
+        self._loopscroll_accum_x -= scroll_x
+        self._loopscroll_accum_y -= scroll_y
+
+        if scroll_x == 0 and scroll_y == 0:
+            return
+
+        surf = self.surface
+        scroll_area_x = (abs(scroll_x), surf.get_height())
+        scroll_area_y = (surf.get_width(), abs(scroll_y))
+        if scroll_x != 0:
+            tempx = pygame.Surface(scroll_area_x, pygame.SRCALPHA)
+        if scroll_y != 0:
+            tempy = pygame.Surface(scroll_area_y, pygame.SRCALPHA)
+
+        top = 0
+        left = 0
+        right = surf.get_width()
+        bottom = surf.get_height()
+
+        if scroll_x > 0: # image is moving right, copy rightmost chunk to left
+            tempx.blit(surf, (0,0), ((right-scroll_x, top), (scroll_x, bottom)))
+            surf.scroll(scroll_x, 0)
+            surf.blit(tempx, (left,top))
+        elif scroll_x < 0: # image is moving left, copy leftmost chunk to right
+            tempx.blit(surf, (0,0), ((0, top), (-scroll_x, bottom)))
+            surf.scroll(scroll_x, 0)
+            surf.blit(tempx, (right+scroll_x,top))
+        
+        if scroll_y > 0: # image is moving down, copy bottom chunk to top
+            tempy.blit(surf, (0,0), ((left, bottom-scroll_y), (right, scroll_y)))
+            surf.scroll(0, scroll_y)
+            surf.blit(tempy, (left, top))
+        elif scroll_y < 0: # image is moving up, copy top chunk to bottom
+            tempy.blit(surf, (0,0), ((left, 0), (right, -scroll_y)))
+            surf.scroll(0, scroll_y)
+            surf.blit(tempy, (left, bottom+scroll_y))
+
+        self.surface = surf

saltpaper/services/renderservice.py

@@ -0,0 +1,34 @@
+import pygame
+
+from saltpaper.services.layer import Layer
+from saltpaper.services.assetservice import AssetService
+from saltpaper.worldsystem.components.sprite import Sprite
+
+class RenderService():
+    def __init__(self, world, assetservice: AssetService):
+        self.world = world
+        self.assetservice = assetservice
+        self.render_queue:dict[Layer, list] = {}
+        
+    def _queue(self, layer:Layer, pos:tuple[int,int], surface:pygame.Surface):
+        item = (surface, pos)
+        if not self.render_queue.get(layer, None):
+            self.render_queue[layer] = []
+        self.render_queue[layer].append(item)
+
+    def _process_queue(self):
+        for layer, items in self.render_queue.items():
+            layer.surface.blits(items)
+        self.render_queue.clear()
+
+    def render(self, layer:Layer, pos:tuple[int,int], asset_id:str):
+        surf = self.assetservice.get_asset(asset_id)
+        self._queue(layer, pos, surf)
+
+    def _render_renderables(self, renderables):
+        for renderable in renderables:
+            self.render(renderable.layer, renderable.position, renderable.asset_id)
+
+    def tick(self):
+        self._render_renderables(self.world.collect_component_type(Sprite))
+        self._process_queue()

saltpaper/services/stateservice.py

@@ -0,0 +1,7 @@
+
+
+class StateService:
+    def __init__(self):
+        ...
+
+        # empty box for user to put shared variables without cluttering globals

saltpaper/worldsystem/components/__init__.py

@@ -0,0 +1,2 @@
+from .position import Position
+from .sprite import Sprite

saltpaper/worldsystem/components/position.py

@@ -0,0 +1,25 @@
+class Position():
+    def __init__(
+            self,
+            layer:int=0,
+            x:int=0,
+            y:int=0,
+            height:int=0,
+            width:int=0
+    ):
+        self.layer = layer
+        self.x = x
+        self.y = y
+        self.height = height
+        self.width = width
+
+    @property
+    def position(self):
+        return (self.x, self.y)
+
+    def set_layer(self, layer):
+        self.layer = layer
+
+    def move(self, dx, dy):
+        self.x += dx
+        self.y += dy

saltpaper/worldsystem/components/sprite.py

@@ -0,0 +1,3 @@
+class Sprite():
+    def __init__(self, asset_id:str="image_missing"):
+        self.asset_id = asset_id

saltpaper/worldsystem/entity.py

@@ -0,0 +1,32 @@
+
+class Entity():
+    def __init__(self, world):
+        self.components = {}
+        world.entities.append(self)
+
+    def add(self, component):
+        self.components[type(component)] = component
+
+    def add_many(self, *components):
+        for component in components:
+            self.add(component)
+
+    def get(self, component_type):
+        for comp_cls, comp in self.components.items():
+            if issubclass(comp_cls, component_type):
+                return comp
+        return None
+
+    def has(self, component_type):
+        return (self.get(component_type) is not None)
+
+    def remove(self, component_type):
+        comp = self.get(component_type)
+        if comp:
+            self.components.pop(type(comp), None)
+
+    def __getattr__(self, name):
+        for component in self.components.values():
+            if hasattr(component, name):
+                return getattr(component, name)
+        raise AttributeError(f"{type(self).__name__} has no attribute '{name}'")

saltpaper/worldsystem/world.py

@@ -0,0 +1,14 @@
+from saltpaper.worldsystem.components.sprite import Sprite
+from saltpaper.worldsystem.entity import Entity
+
+class World():
+    def __init__(self):
+        self.entities: list[Entity] = []
+
+    def collect_component_type(self, component_type):
+        renderables = []
+        for entity in self.entities:
+            if not entity.has(component_type):
+                continue
+            renderables.append(entity)
+        return renderables

saltpaper-0.0.2a0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: saltpaper
+Version: 0.0.2a0
+Summary: A small game-engine/framework built on top of pygame
+Author-email: Lauren Kinder <mail@hermod.uk>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame-ce>=2.4.0
+Requires-Dist: numpy>=1.24.0
+Dynamic: license-file
+
+# saltPAPER
+
+a game engine built on pygame-ce
+
+## usage
+
+TODO
+
+## requirements
+
+- Python >= 3.8
+- pygame-ce >= 2.4.0
+- numpy >= 1.24.0
+- moderngl >= 5.8.0
+
+## attribution
+pygame-ce (LGPL license)

saltpaper-0.0.2a0.dist-info/RECORD

@@ -0,0 +1,29 @@
+saltpaper/__init__.py,sha256=cZ3wNR0lUAwlyUgL4GWFUMvQ5Z1k6QkfIe1RD8ICbWg,173
+saltpaper/assets/.DS_Store,sha256=7-Z-79uIc0CMx4UUj3sSlYE6KAWyk5qlKRTLRnrq8N8,8196
+saltpaper/assets/talk.wav,sha256=rRmMxGFBFGiU59VqfmhIcwdZfuYdY9fUdkv7Os7S3hU,30624
+saltpaper/assets/fonts/LibertinusMono-Regular.ttf,sha256=q9MJTt9ehi35gD8LH8jgr66CFH2oyxsylV3nqPsIOPA,153120
+saltpaper/assets/image/missing.jpg,sha256=OLQF7lfMNkgyL62xxne6Os7NVomL7avXjgeMJJUSrhU,68783
+saltpaper/assets/music/catacomb.wav,sha256=Rx3u6xe2YnST9c7KKJ6seF9bG6rJyC683Sc6j2EGtyQ,15360044
+saltpaper/assets/tilemaps/test.aseprite,sha256=ZmWh2Ima2Lha5t4kjgNMsnlCamBNEKUsO547Hhtoa2w,416
+saltpaper/assets/tilemaps/test.png,sha256=Q2LU88aK3DOLHrXBjuT86ZJTP_ckODwo1g5Pe9Jut7g,927
+saltpaper/assets/tilemaps/test.yaml,sha256=8YWZeFfbxKxSK8MnEYxERjJIpSszMzRxp5lzGNl2yYw,220
+saltpaper/functions/__init__.py,sha256=seVutHUkY36p2YR6oMHmh4RA9ofWhpMKjVxCl-YNxVA,71
+saltpaper/functions/test.py,sha256=sNpRCjy1CrMrlHv770RTtN6iDwB3Hq7-rKdKaTi3b8s,323
+saltpaper/functions/vectortools.py,sha256=I2ok4i0kZqGq5YXgY1nLblgA14mnlC53D2BBSHrbsHM,752
+saltpaper/services/__init__.py,sha256=Sseu7zdeaB3InIIcs5DIRFK4hhGBqxwvTQaAQP8ksaw,292
+saltpaper/services/assetservice.py,sha256=DQOEo3IXWYdrDXrvLztC1Z6f2QeCNk41oGP08w8Ya_c,1957
+saltpaper/services/displayservice.py,sha256=ihyMK8gy3IDYl2HGFhsVMxbTAQo0_r8KiaEk644ummc,2992
+saltpaper/services/inputservice.py,sha256=WNdD0wE2okTbRJDtMBPnxyHmkde0dIocbtSAlX-V408,4884
+saltpaper/services/layer.py,sha256=YoJQ0fwQ4EgXkJWHlgwVd8uv9TnafnmQL1NljoRRxRQ,3089
+saltpaper/services/renderservice.py,sha256=jwhnWoa1a_mHXkoHnK-wREGR0cIBKkGf-pVythHkU1E,1250
+saltpaper/services/stateservice.py,sha256=dxA7H_ABTFyfoClXplFprfD45koN2PGTUQL8-UprO7s,138
+saltpaper/worldsystem/entity.py,sha256=bRyFMfHblzMwzo81YshDkDjvpMXZrEVrvWjgXtdlS5c,987
+saltpaper/worldsystem/world.py,sha256=-8ckweO6pcwaLb42PGKPveuuHNeR_o0cVqUDFcEt93w,442
+saltpaper/worldsystem/components/__init__.py,sha256=ZYfSsWkkqC-Dkl9QwAjPBydca7ifBzxEhG9_OOcMgRs,57
+saltpaper/worldsystem/components/position.py,sha256=lNNh6BoErEEq7SgM347ceLNMOAdnkq1e2LMr_ejZmwE,500
+saltpaper/worldsystem/components/sprite.py,sha256=pQHkyNNKv_iy33LLbqZlOXTU-dqoPzFX7ojjYMOH_BY,102
+saltpaper-0.0.2a0.dist-info/licenses/LICENSE,sha256=Fh0aFC8RSdix3JzjFyLJ3IuzsD1FfsbGFkyqDj5qvXQ,1075
+saltpaper-0.0.2a0.dist-info/METADATA,sha256=bA-yImAorT8KaS85kmudg4tQZIJ7Ma3zquGG18eEmuY,646
+saltpaper-0.0.2a0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+saltpaper-0.0.2a0.dist-info/top_level.txt,sha256=JACZnZhYYkgmdSz3T1JXacHS4L0UM6NbeReLoNLu6jw,10
+saltpaper-0.0.2a0.dist-info/RECORD,,

saltpaper-0.0.2a0.dist-info/WHEEL

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

saltpaper-0.0.2a0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Lauren Kinder
+
+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.

saltpaper-0.0.2a0.dist-info/top_level.txt

@@ -0,0 +1 @@
+saltpaper