simple-graphics-lib 0.0.6__py3-none-any.whl

simple_graphics/__init__.py

@@ -0,0 +1 @@
+from .module import *

simple_graphics/module.py

@@ -0,0 +1,497 @@
+import os
+os.environ["PYGAME_HIDE_SUPPORT_PROMPT"] = "1"
+import pygame
+from inspect import signature, currentframe
+from math import pi
+from typing import Callable
+
+_shapes = []
+_ontick = []
+_key_funcs = {}
+_key_hold_funcs = {}
+_mouse_click_funcs = {}
+_bgcolor = "white"
+_font = "Arial"
+
+pygame.init()
+
+
+class Mouse:
+    @property
+    def x(self):
+        return pygame.mouse.get_pos()[0]
+
+    @property
+    def y(self):
+        return pygame.mouse.get_pos()[1]
+
+
+mouse = Mouse()
+
+
+class Shape:
+    def __init__(self, x, y, color="black", outline=False):
+        self.x = x
+        self.y = y
+        self.color = color
+        self.outline = int(outline)
+        _shapes.append(self)
+
+    def __str__(self):
+        return self.__class__.__name__.lower()
+
+
+class Rect(Shape):
+    def __init__(
+        self,
+        x: int,
+        y: int,
+        width: int = 10,
+        height: int = 10,
+        color: str = "black",
+        outline: bool = False,
+    ):
+        super().__init__(x, y, color, outline)
+        self.width = width
+        self.height = height
+
+    @property
+    def rect(self):
+        return (self.x, self.y, self.width, self.height)
+
+    def is_obj_over(self, ox=None, oy=None):
+        if ox == None:
+            ox = pygame.mouse.get_pos()[0]
+        if oy == None:
+            oy = pygame.mouse.get_pos()[1]
+        x_over = ox > self.x and ox < self.x + self.height
+        y_over = oy > self.y and oy < self.y + self.width
+        return x_over and y_over
+
+    def get_area(self):
+        return self.width * self.height
+
+    def get_perimeter(self):
+        return (2 * self.width) + (2 * self.height)
+
+
+class Circle(Shape):
+    def __init__(
+        self,
+        x: int,
+        y: int,
+        radius: int = 10,
+        color: str = "black",
+        outline: bool = False,
+    ):
+        super().__init__(x, y, color, outline)
+        self.radius = radius
+
+    def is_obj_over(self, ox=None, oy=None):
+        if ox == None:
+            ox = pygame.mouse.get_pos()[0]
+        if oy == None:
+            oy = pygame.mouse.get_pos()[1]
+        inside = (ox - self.x) ** 2 + (oy - self.y) ** 2 < self.radius**2
+        return inside
+
+    def get_area(self):
+        return pi * self.radius ^ 2
+
+
+class Polygon(Shape):
+    def __init__(
+        self, points: list[tuple], color: str = "black", outline: bool = False
+    ):
+        self.color = color
+        self.points = points
+        self.outline = int(outline)
+        _shapes.append(self)
+
+    def is_obj_over(self, ox=None, oy=None):
+        if ox == None:
+            ox = pygame.mouse.get_pos()[0]
+        if oy == None:
+            oy = pygame.mouse.get_pos()[1]
+
+        n = len(self.points)
+        inside = False
+
+        p1x, p1y = self.points[0]
+        for i in range(n + 1):
+            p2x, p2y = self.points[i % n]
+            if oy > min(p1y, p2y):
+                if oy <= max(p1y, p2y):
+                    if ox <= max(p1x, p2x):
+                        if p1y != p2y:
+                            xints = (oy - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                        if p1x == p2x or ox <= xints:
+                            inside = not inside
+            p1x, p1y = p2x, p2y
+        return inside
+
+
+class Line(Shape):
+    def __init__(self, points: list[tuple], width: int = 10, color: str = "black"):
+        self.color = color
+        self.points = points
+        self.width = width
+        _shapes.append(self)
+
+    def is_obj_over(self, ox=None, oy=None):
+        if ox == None:
+            ox = pygame.mouse.get_pos()[0]
+        if oy == None:
+            oy = pygame.mouse.get_pos()[1]
+
+        for i in range(len(self.points) - 1):
+            x1, y1 = self.points[i]
+            x2, y2 = self.points[i + 1]
+
+            dist = self._distance_to_segment(ox, oy, x1, y1, x2, y2)
+
+            if dist <= self.width / 2:
+                return True
+
+        return False
+
+    def _distance_to_segment(self, px, py, x1, y1, x2, y2):
+        dx = x2 - x1
+        dy = y2 - y1
+
+        if dx == 0 and dy == 0:
+            return ((px - x1) ** 2 + (py - y1) ** 2) ** 0.5
+
+        t = max(0, min(1, ((px - x1) * dx + (py - y1) * dy) / (dx * dx + dy * dy)))
+
+        closest_x = x1 + t * dx
+        closest_y = y1 + t * dy
+
+        return ((px - closest_x) ** 2 + (py - closest_y) ** 2) ** 0.5
+
+
+class Text(Shape):
+    def __init__(
+        self,
+        x: int,
+        y: int,
+        text: str,
+        color: str = "black",
+        font=_font,
+        size: int = 36,
+    ):
+        super().__init__(x, y, color)
+        self.text = text
+        self.size = size
+        self.font = pygame.font.SysFont(font, size)
+
+    @property
+    def txtsurf(self):
+        return self.font.render(str(self.text), True, self.color)
+
+    def is_obj_over(self, ox=None, oy=None):
+        if ox == None:
+            ox = pygame.mouse.get_pos()[0]
+        if oy == None:
+            oy = pygame.mouse.get_pos()[1]
+
+        text_width = self.txtsurf.get_width()
+        text_height = self.txtsurf.get_height()
+
+        x_over = ox > self.x and ox < self.x + text_width
+        y_over = oy > self.y and oy < self.y + text_height
+        return x_over and y_over
+
+
+class CollisionManager:
+    @staticmethod
+    def rect_rect(rect1: Rect, rect2: Rect):
+        return pygame.Rect(*rect1.rect).colliderect(pygame.Rect(*rect2.rect))
+
+    @staticmethod
+    def rect_circle(rect: Rect, circle: Circle):
+        closest_x = max(rect.x, min(circle.x, rect.x + rect.width))
+        closest_y = max(rect.y, min(circle.y, rect.y + rect.height))
+        dist = ((circle.x - closest_x) ** 2 + (circle.y - closest_y) ** 2) ** 0.5
+        return dist < circle.radius
+
+    @staticmethod
+    def circle_circle(circle1: Circle, circle2: Circle):
+        dist = ((circle1.x - circle2.x) ** 2 + (circle1.y - circle2.y) ** 2) ** 0.5
+        return dist < circle1.radius + circle2.radius
+
+    @staticmethod
+    def rect_polygon(rect: Rect, polygon: Polygon):
+        corners = [
+            (rect.x, rect.y),
+            (rect.x + rect.width, rect.y),
+            (rect.x, rect.y + rect.height),
+            (rect.x + rect.width, rect.y + rect.height),
+        ]
+        for cx, cy in corners:
+            if polygon.is_obj_over(cx, cy):
+                return True
+        for px, py in polygon.points:
+            if rect.is_obj_over(px, py):
+                return True
+        return False
+
+    @staticmethod
+    def circle_polygon(circle: Circle, polygon: Polygon):
+        if polygon.is_obj_over(circle.x, circle.y):
+            return True
+        for px, py in polygon.points:
+            dist = ((circle.x - px) ** 2 + (circle.y - py) ** 2) ** 0.5
+            if dist < circle.radius:
+                return True
+        return False
+
+    @staticmethod
+    def rect_text(rect, text):
+        text_width = text.txtsurf.get_width()
+        text_height = text.txtsurf.get_height()
+        return pygame.Rect(*rect.rect).colliderect(
+            pygame.Rect(text.x, text.y, text_width, text_height)
+        )
+
+    @staticmethod
+    def circle_text(circle, text):
+        text_width = text.txtsurf.get_width()
+        text_height = text.txtsurf.get_height()
+        closest_x = max(text.x, min(circle.x, text.x + text_width))
+        closest_y = max(text.y, min(circle.y, text.y + text_height))
+        dist = ((circle.x - closest_x) ** 2 + (circle.y - closest_y) ** 2) ** 0.5
+        return dist < circle.radius
+
+    def no_collsion_method(shape1, shape2):
+        raise Exception(f"{type(shape1)} and {type(shape2)} have no collision method")
+
+
+def check_args(func, name):
+    sig = signature(func)
+    param_names = list(sig.parameters)
+    if str(sig) != "()":
+        raise ValueError(
+            f'Functions defined with the @{name} decorator may not take arguments\n but "{func.__name__}" was defined with {param_names}'
+        )
+
+#decorartors like this get weird: if you want to be able to pass arguments in you need to handle 2 cases
+#if theres no arguments then it just takes the function as the argument
+def on_tick(func: Callable):
+    name = currentframe().f_code.co_name
+    check_args(func, name)
+    _ontick.append(func)
+    return func
+
+
+def on_press(target: Callable | str):
+    if callable(target):
+        func = target
+        name = currentframe().f_code.co_name
+        sig = signature(func)
+        param_names = list(sig.parameters)
+        if len(param_names) not in [0, 1]:
+            raise ValueError(
+                f'Functions defined with the @{name} decorator may take 0 or 1 arguments\n but "{func.__name__}" was defined with {param_names}'
+            )
+        func._accepts_key = len(param_names) == 1
+        _key_funcs[None] = func
+        return func
+
+    else:
+
+        def decorator(func):
+            key = target
+            name = currentframe().f_code.co_name
+            sig = signature(func)
+            param_names = list(sig.parameters)
+            if len(param_names) not in [0, 1]:
+                raise ValueError(
+                    f'Functions defined with the @{name} decorator may take 0 or 1 arguments\n but "{func.__name__}" was defined with {param_names}'
+                )
+            func._accepts_key = len(param_names) == 1
+
+            keys = [k.strip() for k in key.split(",")]
+            for k in keys:
+                key_name = k if len(k) == 1 else k.upper()
+                pygame_key = getattr(pygame, f"K_{key_name}")
+                _key_funcs[pygame_key] = func
+            return func
+
+        return decorator
+
+
+def on_hold(target: Callable | str):
+    if callable(target):
+        func = target
+        name = currentframe().f_code.co_name
+        sig = signature(func)
+        param_names = list(sig.parameters)
+        if len(param_names) not in [0, 1]:
+            raise ValueError(
+                f'Functions defined with the @{name} decorator may take 0 or 1 arguments\n but "{func.__name__}" was defined with {param_names}'
+            )
+        func._accepts_key = len(param_names) == 1
+        _key_hold_funcs[None] = func
+        return func
+
+    else:
+
+        def decorator(func):
+            key = target
+            name = currentframe().f_code.co_name
+            sig = signature(func)
+            param_names = list(sig.parameters)
+            if len(param_names) not in [0, 1]:
+                raise ValueError(
+                    f'Functions defined with the @{name} decorator may take 0 or 1 arguments\n but "{func.__name__}" was defined with {param_names}'
+                )
+            func._accepts_key = len(param_names) == 1
+
+            keys = [k.strip() for k in key.split(",")]
+            for k in keys:
+                key_name = k if len(k) == 1 else k.upper()
+                pygame_key = getattr(pygame, f"K_{key_name}")
+                _key_hold_funcs[pygame_key] = func
+            return func
+
+        return decorator
+
+
+def on_click(target: Callable | Shape):
+
+    if callable(target):
+        name = currentframe().f_code.co_name
+        check_args(target, name)
+        _mouse_click_funcs[None] = target
+        return target
+    else:
+
+        def decorator(func):
+            name = currentframe().f_code.co_name
+            check_args(func, name)
+            _mouse_click_funcs[target] = func
+            return func
+
+        return decorator
+
+
+def set_bg(color: str):
+    global _bgcolor
+    _bgcolor = color
+
+
+def clear_screen():
+    _shapes.clear()
+
+
+def is_colliding(shape1: Shape, shape2: Shape) -> bool:
+    method_name = f"{str(shape1)}_{str(shape2)}"
+    method = getattr(CollisionManager, method_name, None)
+    if method is None:
+        method_name = f"{str(shape2)}_{str(shape1)}"
+        method = getattr(CollisionManager, method_name, None)
+        if method is None:
+            raise Exception(
+                f"{type(shape1).__name__} and {type(shape2).__name__} have no collision method"
+            )
+        return method(shape2, shape1)
+    return method(shape1, shape2)
+
+
+def run(
+    width: int = 200,
+    height: int = 200,
+    resizable: bool = True,
+    caption: str = "SG window",
+):
+
+    global _bgcolor
+
+    if resizable:
+        screen = pygame.display.set_mode((width, height), pygame.RESIZABLE)
+    else:
+        screen = pygame.display.set_mode((width, height))
+
+    pygame.display.set_caption(caption)
+    clock = pygame.time.Clock()
+    running = True
+
+    def handle_events():
+        nonlocal running
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            if event.type == pygame.KEYDOWN:
+                if None in _key_funcs:
+                    func = _key_funcs[None]
+                    if hasattr(func, "_accepts_key") and func._accepts_key:
+                        func(pygame.key.name(event.key))
+                    else:
+                        func()
+                if event.key in _key_funcs.keys():
+                    func = _key_funcs[event.key]
+                    if hasattr(func, "_accepts_key") and func._accepts_key:
+                        func(pygame.key.name(event.key))
+                    else:
+                        func()
+            if event.type == pygame.MOUSEBUTTONDOWN:
+                if None in _mouse_click_funcs:
+                    _mouse_click_funcs[None]()
+
+                for shape in _shapes:
+                    if shape.is_obj_over() and shape in _mouse_click_funcs:
+                        _mouse_click_funcs[shape]()
+
+        keys_pressed = pygame.key.get_pressed()
+        for pygame_key, func in _key_hold_funcs.items():
+            if pygame_key is None:
+                if hasattr(func, "_accepts_key") and func._accepts_key:
+                    func(pygame.key.name(event.key))
+                else:
+                    func()
+            elif keys_pressed[pygame_key]:
+                if hasattr(func, "_accepts_key") and func._accepts_key:
+                    func(pygame.key.name(pygame_key))
+                else:
+                    func()
+
+        for func in _ontick:
+            func()
+
+    while running:
+        handle_events()
+
+        screen.fill(_bgcolor)
+
+        for shape in _shapes:
+            if str(shape) == "circle":
+                pygame.draw.circle(
+                    screen, shape.color, (shape.x, shape.y), shape.radius, shape.outline
+                )
+            elif str(shape) == "rect":
+                pygame.draw.rect(
+                    screen,
+                    shape.color,
+                    shape.rect,
+                    shape.outline,
+                )
+            elif str(shape) == "polygon":
+                pygame.draw.polygon(screen, shape.color, shape.points, shape.outline)
+            elif str(shape) == "line":
+                for i in range(1, len(shape.points)):
+                    pygame.draw.line(
+                        screen,
+                        shape.color,
+                        shape.points[i - 1],
+                        shape.points[i],
+                        shape.width,
+                    )
+            elif str(shape) == "text":
+                screen.blit(shape.txtsurf, (shape.x, shape.y))
+
+        pygame.display.flip()
+        clock.tick(60)
+
+    pygame.quit()

simple_graphics_lib-0.0.6.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: simple-graphics-lib
+Version: 0.0.6
+Summary: A simple graphics library for python learners
+Author-email: Max-Hillyer <maxhillyer7012@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Max-Hillyer/Simple_graphics
+Project-URL: Issues, https://github.com/Max-Hillyer/Simple_graphics/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame
+Dynamic: license-file
+
+# Simple Graphics
+--- 
+simple graphics is a lightweight python graphics package that offers a more readable alternative to pygame
+
+simple graphics is meant to be extremely readable, allowing you to focus on the logic of your code instead of graphic specifics 
+
+## Shapes
+
+Simple Graphics offers support for various shapes, that will automatically appear on the screen when defined
+
+---
+### Rect 
+Arguments: 
+| Argument | Type | Role | Default | 
+| :--- | :---: | :---: | ---: | 
+| x | int | The x position of the rect | None | 
+| y | int | The y position of the rect | None | 
+| width | int | the width of the rect | 10 | 
+| height | int | the height of the rect | 10 |
+| color | str | the color of the rect | "black" | 
+| outline | bool | whether the rect is just an outline | False | 
+
+Methods: 
+| Method | Purpose | Arguments | Returns | 
+| :--- | :---: | :---: | ---: |
+| is_obj_over | determines if a point is in the rectangle | x: int, y:int | bool | 
+| get_area | returns the area of the rectangle| None | int | 
+| get_perimeter | returns the perimeter of the rectangle | None | int | 
+
+### Circle
+Arguments: 
+| Argument | Type | Role | Default | 
+| :--- | :---: | :---: | ---: |
+| x | int | the x position of the circle | None | 
+| y | int | the y position of the circle | None | 
+| radius | int | the radius of the circle | 10 |
+| color | str | the color of the circle | "black" | 
+| outline | bool | whether the circle is just an outline | False | 
+
+Methods: 
+| Method | Purpose | Arguments | Returns | 
+| :--- | :---: | :---: | ---: | 
+| is_obj_over | determines if a point is in the circle | x: int, y:int | bool |
+| get_area | returns the area of the circle | None | bool | 
+
+### Polygon 
+Arguments: 
+| Argument | Type | Role | Default | 
+| :--- | :---: | :---: | ---: |
+| points | list[tuple] | the vertices of the polygon | None | 
+| color | str | the color of the polygon | "black" | 
+| outline | bool | whther the polygon is just an outline | False | 
+
+Methods: 
+| Method | Purpose | Arguments | Returns | 
+| :--- | :---: | :---: | ---: | 
+| is_obj_over | determines if a point is in the polygon | x: int, y:int | bool |
+
+### Line
+Arguments: 
+| Argument | Type | Role | Default | 
+| :--- | :---: | :---: | ---: |
+| points | list[tuple] |the points that the line will connect | None |
+| width | int | the width of the line | 10 | 
+| color | str | the color of the line | "black" | 
+
+Methods: 
+| Method | Purpose | Arguments | Returns | 
+| :--- | :---: | :---: | ---: | 
+| is_obj_over | determines if a point is over the line | x: int, y:int | bool |
+
+### Text 
+Arguments:
+| Argument | Type | Role | Default | 
+| :--- | :---: | :---: | ---: |
+| x | int | the x value of the text | None | 
+| y | int | the y value of the text | None | 
+| text | str | the text of the text | None | 
+| color | str | the color of the text | "black" | 
+| size | int | the size of the text | 36 | 
+
+Methods: 
+| Method | Purpose | Arguments | Returns | 
+| :--- | :---: | :---: | ---: | 
+| is_obj_over | determines if a point is in the text | x: int, y:int | bool |
+
+---
+
+## Run 
+`run()` is Simple Graphics main function. 
+it creates a screen where all defined objects appear and can be interacted with. 
+
+Arguments:
+| Argument | Type | Role | Default | 
+| :--- | :---: | :---: | ---: | 
+| width | int | The screen width in pixels | 200 | 
+| height | int | the screen height in pixels | 200 | 
+| resizable | bool | whether or not the screen is resizable via dragging | True | 
+| caption | str | the name of the graphics window | "SG window" | 
+
+
+## Collisions 
+
+to check for a collision between 2 shapes, use the `is_colliding()` method: 
+```python 
+rect1 = Rect(10, 10)
+ball = Circle(10 , 5)
+print(is_colliding(ball, rect1)) # True
+```
+---
+## Events 
+
+Instead of a for loop, Simple Graphics handles events using decorators
+
+### on_tick 
+The `on_tick` decorator runs the function every frame
+The default framerate is 60 FPS
+Functions with the `on_tick` decorator may not take arguments
+```python
+@on_tick 
+def main(): 
+    do_something()
+
+run()
+```
+
+### on_press 
+
+the `on_press` runs the decorator whenever a specified button is pressed, or when any button is pressed if none are specified
+
+The function below will run whenever w or s is pressed
+```python
+@on_press("w,s")
+def do_w():
+    do_soemthing() 
+
+run()
+```
+
+The function below will run whenever any key is pressed 
+```python
+@on_press
+def any_key():
+    do_something()
+
+run()
+```
+
+Functions with the `@on_press` decorator may only take 1 argument, which will show up as the key pressed
+```python
+@on_press 
+def print_key(key):
+    print(key)
+
+run()
+```
+
+### on_hold
+
+the `on_hold` decorator functions exactly like the `on_press` decorator, but the function runs every frame for as long as the key is held, instead of just once
+
+The function below will run for as long as w or s is pressed
+```python
+@on_hold("w,s")
+def do_w():
+    do_soemthing() 
+
+run()
+```
+
+The function below will run while any key is pressed 
+```python
+@on_press
+def any_key():
+    do_something()
+
+run()
+```
+
+Functions with the `@on_hold` decorator may only take 1 argument, which will show up as the key held
+```python
+@on_press 
+def print_key(key):
+    print(key)
+
+run()
+```
+
+### on_click
+
+functions defined with the `on_click` decorator will run whenever the specified object is clicked, or whenever any click is detected if none is specified
+
+the function below will run whenever the button rect is clicked
+```python
+button = Rect(10, 10)
+@on_click(button)
+def click_button():
+    print("button clicked")
+
+run()
+```
+
+the function below will run when there is any click at all
+
+```python
+@on_click
+def print_click():
+    print("clicked!")
+
+run()
+```
+
+---
+## The mouse
+A mouse object is already initialized in the Simple Graphics import 
+
+to get mouse coordinates, simply use `mouse.x` and `mouse.y`
+
+Example: 
+```python
+@on_tick
+def main():
+    print(mouse.x, mouse.y)
+
+run()
+```
+---
+## Miscellaneous Functions
+
+### set_bg
+`set_bg()` simply sets the background to the specified color
+
+the default background color is white
+```python
+set_bg("black")
+``` 
+changes the background color to black
+
+### clear_screen
+`clear_screen()` clears the screen. 
+objects defined before a screen clear can no longer be interacted with

simple_graphics_lib-0.0.6.dist-info/RECORD

@@ -0,0 +1,7 @@
+simple_graphics/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
+simple_graphics/module.py,sha256=xOZ88TvHBZwjaQ5T67_1IBgc5Y-vSQmF2IS1IsRNgWE,15110
+simple_graphics_lib-0.0.6.dist-info/licenses/LICENSE,sha256=6L13tZqbSqIm3fN66mTM7SRf3aYrxaQF8hEZSRDfDmU,1068
+simple_graphics_lib-0.0.6.dist-info/METADATA,sha256=cfK1W8MdXM8TmpeJUZFGDfWs9sb7z8dSHMOG-0RAb5Y,6807
+simple_graphics_lib-0.0.6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+simple_graphics_lib-0.0.6.dist-info/top_level.txt,sha256=gJYGGq0qKokydvVsxuGl4VHrAmHRZG11qhQDerRTYdI,16
+simple_graphics_lib-0.0.6.dist-info/RECORD,,

simple_graphics_lib-0.0.6.dist-info/WHEEL

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

simple_graphics_lib-0.0.6.dist-info/licenses/LICENSE

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

simple_graphics_lib-0.0.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+simple_graphics