batframework 1.0.8a1__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/transition.py

@@ -1,215 +1,157 @@
-import batFramework as bf
-from typing import Self
 import pygame
-
-"""
-Both surfaces to transition need to be the same size
-
-"""
-
-
-class Transition:
-    def __init__(
-        self, duration: float, easing_function: bf.easing = bf.easing.LINEAR
-    ) -> None:
-        """
-        duration : time in seconds
-        easing function : controls the progression rate
-        """
-        self.duration: float = duration
-        self.controller = bf.EasingController(
-            easing_function,
-            duration,
-            update_callback=self.update,
-            end_callback=self.end,
-        )
-        self.start_callback = None
-        self.update_callback = None
-        self.end_callback = None
-        self.source: pygame.Surface = None
-        self.dest: pygame.Surface = None
-
-    def __repr__(self) -> str:
-        return f"Transition {self.__class__},{self.duration}"
-
-    def set_start_callback(self, func) -> Self:
-        self.start_callback = func
-        return self
-
-    def set_update_callback(self, func) -> Self:
-        self.update_callback = func
-        return self
-
-    def set_end_callback(self, func) -> Self:
-        self.end_callback = func
-        return self
-
-    def set_source(self, surface: pygame.Surface) -> None:
-        self.source = surface
-
-    def set_dest(self, surface: pygame.Surface) -> None:
-        self.dest = surface
-
-    def start(self):
-        if self.controller.has_started():
-            return
-        if self.duration:
-            self.controller.start()
-            if self.start_callback:
-                self.start_callback()
-            return
-
-        self.controller.start()
-        if self.start_callback:
-            self.start_callback()
-        self.controller.end()
-        self.update(1)
-        self.end()
-
-    def update(self, progression: float) -> None:
-        if self.update_callback:
-            self.update_callback(progression)
-
-    def end(self):
-        self.controller.stop()
-        if self.end_callback:
-            self.end_callback()
-
-    def draw(self, surface: pygame.Surface) -> None:
-        pass
-
-    def skip(self, no_callback: bool = False):
-        self.controller.stop()
-        if self.end_callback and (no_callback == False):
-            self.end_callback()
+import batFramework as bf
 
 
-class FadeColor(Transition):
+class BaseTransition:
     def __init__(
         self,
-        color: tuple | str,
-        middle_duration: float,
-        first_duration: float = None,
-        second_duration: float = None,
-        easing_function: bf.easing = bf.easing.LINEAR,
+        source_surf: pygame.Surface,
+        dest_surf: pygame.Surface,
+        duration=100,
+        **kwargs,
     ) -> None:
-        super().__init__(0, easing_function)
-        if first_duration is None:
-            first_duration = middle_duration
-        if second_duration is None:
-            second_duration = middle_duration
+        self.source = source_surf
+        self.dest = dest_surf
+        self.ended = False
+        self.source_scene_name = ""
+        self.dest_scene_name = ""
+        self.duration = duration
         self.index = 0
-        self.first = Fade(first_duration)
-        self.color = color
-        self.second = Fade(second_duration).set_end_callback(
-            lambda: self.next_step(self.end)
-        )
-        self.timer = bf.Timer(
-            middle_duration, lambda: self.next_step(self.second.start)
-        )
-        self.first.set_end_callback(lambda: self.next_step(self.timer.start))
-
-    def next_step(self, callback=None) -> None:
-        self.index += 1
-        if callback:
-            callback()
 
-    def set_source(self, surface) -> None:
-        super().set_source(surface)
-        self.first.set_source(surface)
+    def set_scene_index(self,index):
+        self.index = index
 
-    def set_dest(self, surface) -> None:
-        super().set_dest(surface)
-        self.second.set_dest(surface)
+    def set_source_name(self, name):
+        self.source_scene_name = name
 
-    def start(self):
-        if self.start_callback:
-            self.start_callback()
-        self.color_surf = pygame.Surface(self.source.get_size())
-        self.color_surf.fill(self.color)
+    def set_dest_name(self, name):
+        self.dest_scene_name = name
 
-        self.first.set_dest(self.color_surf)
-        self.second.set_source(self.color_surf)
-        self.first.start()
+    def update(self, dt):
+        pass
 
     def draw(self, surface):
-        if self.index == 0:
-            self.first.draw(surface)
-        elif self.index == 1:
-            surface.blit(self.color_surf, (0, 0))
-        else:
-            self.second.draw(surface)
-
-    def skip(self, no_callback: bool = False):
-        if (no_callback == False) and self.end_callback:
-            self.end_callback()
-
-        self.first.controller.stop()
-        self.timer.stop()
-        self.second.controller.stop()
+        pass
 
+    def has_ended(self):
+        return False
 
-class Fade(Transition):
-    def end(self):
-        self.dest.set_alpha(255)
-        return super().end()
+    def set_ended(self, val):
+        self.ended = val
 
-    def draw(self, surface):
-        dest_alpha = 255 * self.controller.get_value()
-        self.dest.set_alpha(dest_alpha)
-        surface.blit(self.source, (0, 0))
-        surface.blit(self.dest, (0, 0))
 
+class FadeColorTransition(BaseTransition):
+    def __init__(
+        self,
+        source_surf,
+        dest_surf,
+        duration=600,
+        color_duration=200,
+        color=bf.color.CLOUD_WHITE,
+        **kwargs,
+    ) -> None:
+        super().__init__(source_surf, dest_surf, duration)
+        self.target_time = duration * 2 + color_duration
+        self.color_surf = pygame.Surface((source_surf.get_rect().size)).convert_alpha()
+        self.color_surf.fill(color)
+        self.ease_out = bf.EasingAnimation(
+            easing_function=bf.Easing.EASE_IN,
+            duration=(duration-color_duration)//2,
+            update_callback = lambda x: self.color_surf.set_alpha(int(255 - (255 * x))),
+            end_callback=lambda: self.set_ended(True))
+
+        self.color_timer = bf.Timer(
+            duration=color_duration,
+            end_callback=lambda: self.set_state("out"))
+        self.ease_in = bf.EasingAnimation(
+            easing_function=bf.Easing.EASE_IN,
+            duration=(duration-color_duration)//2,
+            update_callback=lambda x: self.color_surf.set_alpha(int(255 * x)),
+            # update_callback=lambda x: print(x),
+            end_callback=lambda: self.set_state("color"))
+        self.state = None
+
+        self.state = "in"
+        self.ease_in.start()
+
+    def set_state(self, state: str):
+        self.state = state
+        if state == "in":
+            self.ease_in.start()
+        elif state == "color":
+            self.color_timer.start()
+        elif state == "out":
+            self.ease_out.start()
+
+    def has_ended(self):
+        return self.ended
+
+    def set_ended(self, val):
+        super().set_ended(val)
 
-class GlideRight(Transition):
     def draw(self, surface):
-        width = surface.get_width()
-        source_x = -self.controller.get_value() * width
-        surface.blit(self.source, (source_x, 0))
-        surface.blit(self.dest, (width + source_x, 0))
+        if self.state != "color":
+            surface.blit(self.source if self.state == "in" else self.dest, (0, 0))
+        surface.blit(self.color_surf, (0, 0))
 
 
-class GlideLeft(Transition):
-    def draw(self, surface):
-        width = surface.get_width()
-        source_x = self.controller.get_value() * width
-        surface.blit(self.source, (source_x, 0))
-        surface.blit(self.dest, (source_x - width, 0))
+class FadeTransition(BaseTransition):
+    def __init__(self, source_surf, dest_surf, duration=500) -> None:
+        super().__init__(source_surf, dest_surf)
+        self.anim = bf.EasingAnimation(None,bf.Easing.EASE_IN_OUT,duration,self.update_surface,lambda : self.set_ended(True))
+        self.anim.start()
 
+    def update_surface(self,progress):
+        self.source.set_alpha(int(255 - (255 * progress)))
+        self.dest.set_alpha(int(255 * progress))
 
-class CircleOut(Transition):
-    def start(self):
-        super().start()
-        self.circle_surf = self.source.copy()
-        self.circle_surf.set_colorkey((0, 0, 0))
-        self.circle_surf.fill((0, 0, 0))
-        self.surface_width = self.circle_surf.get_width()
+    def has_ended(self):
+        return self.ended
 
     def draw(self, surface):
-        v = self.controller.get_value()
+        surface.blit(self.source, (0, 0))
+        surface.blit(self.dest, (0, 0))
+
 
-        radius = self.surface_width * v
-        pygame.draw.circle(
-            self.circle_surf, "white", self.circle_surf.get_rect().center, radius
+class SlideTransition(BaseTransition):
+    def __init__(
+        self,
+        source_surf,
+        dest_surf,
+        duration=1000,
+        source_alignment: bf.Alignment = bf.Alignment.BOTTOM,
+        easing: bf.Easing = bf.Easing.EASE_IN_OUT,
+        **kwargs,
+    ) -> None:
+        super().__init__(source_surf, dest_surf, duration)
+        self.offset = pygame.Vector2(0, 0)
+        if source_alignment in [bf.Alignment.TOP, bf.Alignment.BOTTOM]:
+            self.offset.y = bf.const.RESOLUTION[1]
+            if source_alignment == bf.Alignment.TOP:
+                self.offset.y *= -1
+        elif source_alignment in [bf.Alignment.LEFT, bf.Alignment.RIGHT]:
+            self.offset.x = bf.const.RESOLUTION[0]
+            if source_alignment == bf.Alignment.LEFT:
+                self.offset.x *= -1
+        else:
+            self.offset.x = -bf.const.RESOLUTION[0]
+            print(
+                f"Unsupported Alignment : {source_alignment.value}, set to default : {bf.Alignment.LEFT.value} "
+            )
+        self.anim = bf.EasingAnimation(
+            easing_function=easing,
+            duration=duration,
+            update_callback =lambda x: self.update_offset(self.offset.lerp((0, 0), x)),
+            end_callback =lambda: self.set_ended(True),
         )
-        mask = pygame.mask.from_surface(self.circle_surf)
-        mask.to_surface(surface=surface, setsurface=self.dest, unsetsurface=self.source)
+        self.anim.start()
 
+    def update_offset(self, vec):
+        self.offset.update(vec)
 
-class CircleIn(Transition):
-    def start(self):
-        super().start()
-        self.circle_surf = self.source.copy()
-        self.circle_surf.set_colorkey((0, 0, 0))
-        self.circle_surf.fill((0, 0, 0))
-        self.surface_width = self.circle_surf.get_width()
+    def has_ended(self):
+        return self.ended
 
     def draw(self, surface):
-        v = self.controller.get_value()
-        radius = self.surface_width - (self.surface_width * v)
-        self.circle_surf.fill((0, 0, 0))
-        pygame.draw.circle(
-            self.circle_surf, "white", self.circle_surf.get_rect().center, radius
-        )
-        mask = pygame.mask.from_surface(self.circle_surf)
-        mask.to_surface(surface=surface, setsurface=self.source, unsetsurface=self.dest)
+        surface.blit(self.source, (0, 0))
+        surface.blit(self.dest, self.offset)

batFramework/utils.py

@@ -3,8 +3,10 @@ from enum import Enum
 import os
 import batFramework as bf
 import json
-from .enums import *
-import re
+
+MAX_FONT_SIZE = 100
+MIN_FONT_SIZE = 8
+
 class Singleton(type):
     _instances = {}
 
@@ -14,44 +16,169 @@ class Singleton(type):
         return cls._instances[cls]
 
 
+class Direction(Enum):
+    HORIZONTAL = "horizontal"
+    VERTICAL = "vertical"
+
+
+class Alignment(Enum):
+    LEFT = "left"
+    RIGHT = "right"
+    CENTER = "center"
+    TOP = "top"
+    BOTTOM = "bottom"
+
+
+class Layout(Enum):
+    FILL = "fill"
+    FIT = "fit"
+
+
 class Utils:
+    pygame.font.init()
+    FONTS = {}
+    tilesets = {}
+
+    @staticmethod
+    def get_path(path: str):
+        return os.path.join(bf.const.RESOURCE_PATH, path)
 
     @staticmethod
-    def split_surface(
-        surface : pygame.Surface, split_size: tuple[int, int], func=None
-    ) -> dict[tuple[int, int], pygame.Surface]:
-        """
-        Splits a surface into subsurfaces and returns a dictionnary of them
-        with their tuple coordinates as keys.
-        Exemple : '(0,0) : Surface' 
-        """
-        if surface is None:
+    def load_json_from_file(path: str) -> dict:
+        try:
+            with open(Utils.get_path(path), "r") as file:
+                data = json.load(file)
+            return data
+        except FileNotFoundError:
+            print(f"File '{path}' not found")
             return None
-        width, height = surface.get_size()
-        res = {}
-        for iy, y in enumerate(range(0, height, split_size[1])):
-            for ix, x in enumerate(range(0, width, split_size[0])):
-                sub = surface.subsurface((x, y, split_size[0], split_size[1]))
 
-                if func is not None:
-                    sub = func(sub)
+    @staticmethod
+    def save_json_to_file(path: str, data) -> bool:
+        try:
+            with open(Utils.get_path(path), "w") as file:
+                json.dump(data, file, indent=2)
+            return True
+        except FileNotFoundError:
+            return False
+            
+    @staticmethod
+    def init_font(raw_path:str):
+            try :
+                if raw_path is not None:
+                    Utils.load_font(raw_path if raw_path else None,None)
+                Utils.load_font(raw_path)
+            except FileNotFoundError:
+                Utils.load_sysfont(raw_path)
+                Utils.load_sysfont(raw_path,None)
 
-                res[(ix, iy)] = sub
 
-        return res
-    
     @staticmethod
-    def filter_text(text_mode: textMode):
-        if text_mode == textMode.ALPHABETICAL:
-            pattern = re.compile(r'[^a-zA-Z]')
-        elif text_mode == textMode.NUMERICAL:
-            pattern = re.compile(r'[^0-9]')
-        elif text_mode == textMode.ALPHANUMERICAL:
-            pattern = re.compile(r'[^a-zA-Z0-9]')
+    def load_font(path:str,name:str=''):
+        if path is not None: path = Utils.get_path(path) # convert path if given
+        filename = os.path.basename(path).split('.')[0] if path is not None else None # get filename if path is given, else None
+        if name != '' : filename = name # if name is not given, name is the filename
+        Utils.FONTS[filename] = {}
+        # fill the dict 
+        for size in range(MIN_FONT_SIZE, MAX_FONT_SIZE, 2):
+            Utils.FONTS[filename][size] = pygame.font.Font(path,size=size)
+
+    def load_sysfont(font_name:str,key:str=''):
+        if key == '' : key = font_name
+        if pygame.font.match_font(font_name) is None: 
+            raise FileNotFoundError(f"Requested font '{font_namey}' was not found")
+        Utils.FONTS[font_name] = {}
+
+        for size in range(MIN_FONT_SIZE, MAX_FONT_SIZE, 2):
+            Utils.FONTS[key][size] = pygame.font.SysFont(font_name,size=size)  
+              
+
+    @staticmethod
+    def get_font(name:str|None=None,text_size:int=12) -> pygame.Font:
+        if not name in Utils.FONTS: return None
+        if not text_size in Utils.FONTS[name]: return None
+        return Utils.FONTS[name][text_size]
+
+    class Tileset:
+        _flip_cache = {}  # {"tileset":tileset,"index","flipX","flipY"}
+
+        def __init__(self, surface: pygame.Surface, tilesize) -> None:
+            self.tile_dict = {}
+            self.surface = surface
+            self.tile_size = tilesize
+            self.split_surface(surface)
+
+        def split_surface(self, surface: pygame.Surface):
+            width, height = surface.get_size()
+            num_tiles_x = width // self.tile_size
+            num_tiles_y = height // self.tile_size
+            # Iterate over the tiles vertically and horizontally
+            for y in range(num_tiles_y):
+                for x in range(num_tiles_x):
+                    # Calculate the coordinates of the current tile in the tileset
+                    tile_x = x * self.tile_size
+                    tile_y = y * self.tile_size
+                    # Create a subsurface for the current tile
+                    tile_surface = surface.subsurface(
+                        pygame.Rect(tile_x, tile_y, self.tile_size, self.tile_size)
+                    )
+                    # Calculate the unique key for the tile (e.g., based on its coordinates)
+                    tile_key = (x, y)
+                    # Store the subsurface in the dictionary with the corresponding key
+                    self.tile_dict[tile_key] = tile_surface
+            # print(self.tile_dict)
+
+        def get_tile(self, x, y, flipX=False, flipY=False) -> pygame.Surface | None:
+            if (x, y) not in self.tile_dict:
+                return None
+            if flipX or flipY:
+                key = f"{x}{y}:{flipX}{flipY}"
+                if not key in self._flip_cache:
+                    self._flip_cache[key] = pygame.transform.flip(
+                        self.tile_dict[(x, y)], flipX, flipY
+                    )
+                return self._flip_cache[key]
+            return self.tile_dict[(x, y)]
+
+    @staticmethod
+    def img_slice(file, cell_width, cell_height, flipX=False) -> list[pygame.Surface]:
+        src = pygame.image.load(
+            os.path.join(bf.const.RESOURCE_PATH, file)
+        ).convert_alpha()
+        width, height = src.get_size()
+        res = []
+        for y in range(0, height, cell_height):
+            for x in range(0, width, cell_width):
+                sub = src.subsurface((x, y, cell_width, cell_height))
+                if flipX:
+                    sub = pygame.transform.flip(sub, True, False)
+
+                res.append(sub)
+        return res
+
+    def load_tileset(path: str, name: str, tilesize):
+        if name in Utils.tilesets:
+            return Utils.tilesets[name]
         else:
-            raise ValueError("Unsupported text mode")
-        
-        def filter_function(s: str) -> str:
-            return pattern.sub('', s)
-        
-        return filter_function
+            img = pygame.image.load(
+                os.path.join(bf.const.RESOURCE_PATH, path)
+            ).convert_alpha()
+            tileset = Utils.Tileset(img, tilesize)
+            Utils.tilesets[name] = tileset
+            return tileset
+
+    @staticmethod
+    def get_tileset(name: str) -> Tileset:
+        if name not in Utils.tilesets:
+            return None
+        return Utils.tilesets[name]
+
+
+    
+
+
+def move_points(delta, *points):
+    res = []
+    for point in points:
+        res.append((point[0] + delta[0], point[1] + delta[1]))
+    return res

batframework-1.0.8a2.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: batframework
+Version: 1.0.8a2
+Summary: Pygame framework for making games easier.
+Author-email: Turan Baturay <baturayturan@gmail.com>
+Project-URL: Homepage, https://github.com/TuranBaturay/batFramework
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pygame-ce
+
+# batFramework
+
+batFramework is a Python game framework built using Pygame, designed to simplify game development by providing entities, scenes, a scene manager, and various utilities.
+
+## Purpose and Overview
+The primary objective of batFramework is to streamline game development by utilizing entities and scenes that hold entities. It employs a manager, which inherits from the scene manager, to handle scenes, propagate events, and manage updates and rendering.
+
+## Installation and Setup
+To install batFramework, you can use pip:
+```pip install batFramework```
+
+
+The only dependency required is pygame-ce.
+
+## Usage Instructions
+To create a basic app using batFramework, here's an example:
+
+```python
+import batFramework as bf
+
+# Initialize the framework
+bf.init((1280, 720), window_title="My Amazing Program")
+
+# Create a manager and a scene
+bf.Manager(bf.Scene("main")).run()
+```
+In practice, users can inherit bf.Scene to create their own scenes, adding specific behaviors, entities, etc.
+
+## Features and Functionalities
+
+- Scene management for organizing game components
+- Cutscene support to facilitate storytelling sequences
+- Audio management for music and sound effects with volume control
+- Entity, sprite, and animated sprite support
+- Utility modules such as time management and easingAnimation
+
+Users can leverage these functionalities to build games efficiently using batFramework.
+
+For more detailed usage and examples, please refer to the documentation or codebase.
+
+
+# License
+ MIT License
+
+

batframework-1.0.8a2.dist-info/RECORD

@@ -0,0 +1,42 @@
+batFramework/__init__.py,sha256=MLVXC2ymkO3k8LdCgB6TbahgJfhxk4GKAbmndmEgZS4,2146
+batFramework/action.py,sha256=Phk6-q2P-XyV2GVlXPpxyje0due4fIrKnhI1_4anfjI,7600
+batFramework/actionContainer.py,sha256=K9dIgG559ckxzRB3t-lpON4dFTcM2mcKZfsf4bhuJ1k,1092
+batFramework/animatedSprite.py,sha256=kJPKrTOfkbQu2uYDziIEop1z6-gjBwZxkC1Rxd_vBwE,3992
+batFramework/audioManager.py,sha256=5UsDPy4zsDO7Va1y1kM4lSpEJXU95o9F01E-Sts3osg,2546
+batFramework/camera.py,sha256=wt4TyWTgQmQElBVeFI7ONzNI75r0FKtB3KmNH00GeFM,4322
+batFramework/constants.py,sha256=FSyEYLxdAb3JaXA11sAwZBfAImedASohpFcd_7qnG0I,2075
+batFramework/cutscene.py,sha256=5aiIQeWGmvHCb-N3vjmwxhE4dCXv3iZRFHiexSNxCXM,3650
+batFramework/cutsceneBlocks.py,sha256=1gmof0jKJ8SqE-RoErm6n1A0JJ4Ang9Q30xEZnW9NaI,5123
+batFramework/debugger.py,sha256=gh5kOUmGr4t-BFXA17tImid4nzxUqrhsUhE_JV9srNg,1671
+batFramework/dynamicEntity.py,sha256=REIqH0jnfX6yUThoQNkQrsG0390TR6C5la1h2MAioYk,665
+batFramework/easing.py,sha256=vGkk7FDPj27X7NCJXALCEyVKDbpXXebWYtMvxkbhOh0,2217
+batFramework/entity.py,sha256=Tw4_PIA_sY8fhbj9TjE6wPcDTrZZX_Tj7l8oKquqe8U,3178
+batFramework/manager.py,sha256=LdiQVyuPQE23jwO4EjR4zqDymxtRmthUJ7VE7RIEDpU,1583
+batFramework/particles.py,sha256=PX8zSqOS1gyDloGAz3fAlrto51lWMUpBXDIM152EYWc,2172
+batFramework/scene.py,sha256=KM1e53ZfPvuJoSGQZaEl_IouWRYCbFq0QOYTuXYCr-E,7324
+batFramework/sceneManager.py,sha256=sFkQbfMuR19M4duvCf0SOxSY7MkMrkmiiKh72-tC1nI,5743
+batFramework/stateMachine.py,sha256=_er9_dcm6MLmlTjXTVm175eqZ9puaKb31PFmNPRhcSU,1338
+batFramework/time.py,sha256=iGV9mxUFrdXsvm4fJ1faX-VYNsOH7DX2N_aXsDRHhmM,2403
+batFramework/transition.py,sha256=wmL1Mgg_xopzeDbEPJyAmllLB2BCRJZtuMOR7Mez480,4873
+batFramework/transitionManager.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+batFramework/triggerZone.py,sha256=ikOOlJT1KIND0MO2xiilCHuKlb1eQhkCMEhZTi1btsI,586
+batFramework/utils.py,sha256=EUB3bMldWTYFVZxcJk5_7XAWcEz080P7PT5ZtkO5TAQ,6164
+batFramework/gui/__init__.py,sha256=azu5HpC8Q9kupythU5GN5blt7K9oH55oXlOeXsIw1Mw,391
+batFramework/gui/button.py,sha256=05RMQ20P5npgU9QmiT8v6abJhnhjqRgYbpZGaQXr6Bg,2703
+batFramework/gui/constraints.py,sha256=pUTNwJqI2Tu57l8ZeQXVXg3b5F5t3aR4Us-CD5qXwnM,7544
+batFramework/gui/container.py,sha256=XAkPZ0BOVXxzxWP5mKDF_MjYPPPAmUBY-J5zIadO0wQ,1480
+batFramework/gui/debugger.py,sha256=JORHcSYQQCZ0tDzjnNQvDSOOjZVwEQLeqlr8e6xk2RI,1379
+batFramework/gui/frame.py,sha256=zjHwbQT1fpRuvNgfBGZhMO_GdMEWqExa5dNlN9kUnUM,514
+batFramework/gui/image.py,sha256=goOcPntsJeTb3LR7avzi4cXfYHwyGb0KXYttbCiE6fA,777
+batFramework/gui/indicator.py,sha256=OgqDFsi2HCfbSzVjHkHO_shmo4q4ro3wfd0LWSLTJeQ,957
+batFramework/gui/interactiveWidget.py,sha256=rRElxI1eFkvOeTfTaA6f8kVTOswOD-DFLAJDUCAI_Yk,641
+batFramework/gui/label.py,sha256=EO1J5zPVe1skHz-KVqXKBZVKug8UVJUCXyHnvdRDuig,3586
+batFramework/gui/layout.py,sha256=HyVhYTy1AQacALg6XMY5aX5lj7WY__HCCh8sTSBXwgI,3210
+batFramework/gui/root.py,sha256=mhlu8ohqq8N-8q__ugv_tGRgPv-1jIHXBFezMFZ4mUM,1763
+batFramework/gui/shape.py,sha256=CYaD0BdCiuGJO_tS2pALfKPlNGaGRNPzvy-Lk08_R8g,2490
+batFramework/gui/toggle.py,sha256=jAeEyQXA893gDBUmjN7aoGgfsVln5RTODpSFB4LxwTY,2020
+batFramework/gui/widget.py,sha256=1PkxThmet8nI5rvSDE6-iPtD_DsZkk-OxriZHbBZaFc,10509
+batframework-1.0.8a2.dist-info/METADATA,sha256=YnyIVG7YvAIqBiqWVbeQ6h4tWUT7VHAHUr_Is1uQyJw,1980
+batframework-1.0.8a2.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+batframework-1.0.8a2.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.8a2.dist-info/RECORD,,

{batframework-1.0.8a1.dist-info → batframework-1.0.8a2.dist-info}/WHEEL

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