e2D 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

e2D/__init__.py

@@ -15,8 +15,8 @@ DOUBLE_PI = PI*2
 # 
 
 class Vector2D:
-    round_values_on_print = False
-    def __init__(self:"V2|Vector2D", x:int|float=0, y:int|float=0) -> None:
+    round_values_on_print :float= 1.0
+    def __init__(self:"V2|Vector2D", x:int|float=0.0, y:int|float=0.0) -> None:
         """
         # Initialize a 2D vector with the specified x and y components.
 
@@ -67,7 +67,7 @@ class Vector2D:
         self.x = x
         self.y = y
 
-    def distance_to(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple", squared:bool=True) -> int|float:
+    def distance_to(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple", sqrd:bool=True) -> int|float:
         """
         # Calculate the distance between the current Vector2D other and another other.
 
@@ -103,7 +103,7 @@ class Vector2D:
         """
         other = self.__normalize__(other)
         d = (self.x - other.x)**2 + (self.y - other.y)**2
-        return (d**(1/2) if squared else d)
+        return (d**(1/2) if sqrd else d)
 
     def angle_to(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> int|float:
         """
@@ -232,7 +232,7 @@ class Vector2D:
         """
         return Vector2D(self.x, self.y)
 
-    def absolute_round(self:"V2|Vector2D", n=1) -> "Vector2D|V2":
+    def sign(self:"V2|Vector2D") -> "Vector2D|V2":
         """
         # Perform an "absolute round" operation on the Vector2D other.
 
@@ -271,14 +271,16 @@ class Vector2D:
             Note: The "absolute round" operation does not perform standard mathematical rounding; instead, it ensures the resulting
             vector points in the same direction as the original vector but has non-negative components.
         """
-        s_abs = abs(self)
-        return self.no_zero_div_error(s_abs, "zero") * n
+        return self.no_zero_div_error(abs(self), "zero")
 
     def floor(self:"V2|Vector2D", n:"int|float|Vector2D|V2"=1) -> "Vector2D|V2":
         return self.__floor__(n)
 
     def ceil(self:"V2|Vector2D", n:"int|float|Vector2D|V2"=1) -> "Vector2D|V2":
         return self.__ceil__(n)
+    
+    def round(self:"V2|Vector2D", n:"int|float|Vector2D|V2"=1) -> "Vector2D|V2":
+        return self.__round__(n)
 
     def randomize(start:"int|float|Vector2D|V2|None"=None, end:"int|float|Vector2D|V2|None"=None) -> "Vector2D|V2": #type: ignore
         """
@@ -323,39 +325,7 @@ class Vector2D:
             if type(end) in int|float: end = Vector2D(end, end) #type: ignore
             elif type(end) == None: end = Vector2D(1,1)
             else: raise Exception(f"\nArg end must be in [Vector2D, int, float, tuple, list] not a [{type(end)}]\n")
-        return start + Vector2D(_rnd.random(), _rnd.random()) * (end - start)
-
-    def mid_point_to(self:"V2|Vector2D", *others) -> float:
-        """
-        # Calculate the midpoint between the current Vector2D other and one or more other Vector2D others.
-
-        ## Parameters:
-            *others (Vector2D): Variable number of Vector2D others representing other points.
-
-        ## Returns:
-            Vector2D: A new Vector2D other representing the midpoint.
-
-        ## Example:
-            point1 = Vector2D(1, 2)
-
-            point2 = Vector2D(3, 4)
-
-            mid_point = point1.mid_point_to(point2)
-
-            print(mid_point.x, mid_point.y)
-
-            This will print the midpoint between point1 and point2.
-
-        ## Explanation:
-            The function calculates the midpoint between the current Vector2D other (self)
-            and one or more other Vector2D others (provided as *others).
-
-            It first sums up all the Vector2D others (including self) and then divides the sum by
-            the total number of points (len(others) + 1) to find the average point, which represents the midpoint.
-
-            The result is returned as a new Vector2D other.
-        """
-        return sum(list(others) + [self]) / (len(others)+1)
+        return start + Vector2D(_rnd.random(), _rnd.random()) * (end - start) #type: ignore
     
     def dot_product(self, other:"float|int|Vector2D|V2|list|tuple") -> float:
         other = self.__normalize__(other)
@@ -382,30 +352,6 @@ class Vector2D:
             Example usage is shown in the "Example" section above.
         """
         return self.x * other.x + self.y * other.y
-    
-    def magnitude(self) -> float:
-        """
-        # Vector Magnitude (Length)
-
-        ## Returns:
-            float: The magnitude (length) of the vector.
-
-        ## Example:
-            v = Vector2D(3, 4)
-            magnitude_v = v.magnitude()  # Calculate the magnitude of the vector (3, 4)
-            print(magnitude_v)  # Output: 5.0
-
-        ## Explanation:
-            This method calculates the magnitude (length) of the vector.
-            The magnitude of a 2D vector (x, y) is the square root of the sum of the squares of its components.
-
-            The method uses the formula: magnitude = sqrt(x^2 + y^2).
-
-            The resulting magnitude is returned as a floating-point value.
-
-            Example usage is shown in the "Example" section above.
-        """
-        return (self.x ** 2 + self.y ** 2) ** .5
 
     def normalize(self) -> "Vector2D":
         """
@@ -435,7 +381,7 @@ class Vector2D:
 
             Example usage is shown in the "Example" section above.
         """
-        mag = self.magnitude()
+        mag = self.length()
         if mag == 0:
             return self
         return Vector2D(self.x / mag, self.y / mag)
@@ -479,7 +425,7 @@ class Vector2D:
         """
         other = self.__normalize__(other)
         dot_product = self.dot_product(other)
-        magnitude_product = other.magnitude() ** 2
+        magnitude_product = other.length() ** 2
         if magnitude_product == 0:
             raise ValueError("Cannot calculate projection for zero vectors.")
         return other * (dot_product / magnitude_product)
@@ -540,7 +486,7 @@ class Vector2D:
 
             Example usage is shown in the "Example" section above.
         """
-        r = self.magnitude()
+        r = self.length()
         theta = _mt.atan2(self.y, self.x)
         return r, theta
 
@@ -581,7 +527,7 @@ class Vector2D:
         return cls(complex_n.real, complex_n.imag)
 
     def length(self) -> float:
-        return V2z.distance_to(self)
+        return (self.x ** 2 + self.y ** 2) ** .5
 
     def lerp(self, other:"float|int|Vector2D|V2|list|tuple", t: float) -> "Vector2D|V2":
         """
@@ -652,13 +598,19 @@ class Vector2D:
 
             Example usage is shown in the "Example" section above.
         """
-        if center is None:
-            center = V2z
-        else:
-            center = self.__normalize__(center)
+        if center is None: center = V2z
+        else: center = self.__normalize__(center)
+        print(f"CENTER {center}")
         translated = self - center
+        print(f"TRANS {translated}")
         cos_angle = _mt.cos(angle)
+        print(f"COS {cos_angle}")
         sin_angle = _mt.sin(angle)
+        print(f"SIN {sin_angle}")
+        print(translated.x * cos_angle, translated.y * sin_angle, translated.x * cos_angle - translated.y * sin_angle)
+        data = Vector2D(translated.x * cos_angle - translated.y * sin_angle, translated.x * sin_angle + translated.y * cos_angle)
+        print(data.x, data.y, data)
+        print(data + center)
         return Vector2D(translated.x * cos_angle - translated.y * sin_angle, translated.x * sin_angle + translated.y * cos_angle) + center
 
     def no_zero_div_error(self:"Vector2D|V2", n:"int|float|Vector2D|V2", error_mode:str="zero") -> "Vector2D|V2":
@@ -710,7 +662,7 @@ class Vector2D:
             else:
                 return self / n
         elif any(isinstance(n, cls) for cls in {Vector2D, V2}):
-            return Vector2D((0 if error_mode == "zero" else (self.x if error_mode == "null" else _mt.nan)) if n.x == 0 else self.x / n.x, (0 if error_mode == "zero" else (self.y if error_mode == "null" else _mt.nan)) if n.y == 0 else self.y / n.y)
+            return Vector2D((0 if error_mode == "zero" else (self.x if error_mode == "null" else _mt.nan)) if n.x == 0 else self.x / n.x, (0 if error_mode == "zero" else (self.y if error_mode == "null" else _mt.nan)) if n.y == 0 else self.y / n.y) #type: ignore
         else:
             raise Exception(f"\nArg n must be in [Vector2D, int, float, tuple, list] not a [{type(n)}]\n")
 
@@ -723,10 +675,10 @@ class Vector2D:
         return Vector2D(max(self.x, other.x), max(self.y, other.y))
 
     def __str__(self:"V2|Vector2D") -> str:
-        return f"{self.x:.02f}, {self.y:.02f}" if self.round_values_on_print else f"{self.x}, {self.y}"
+        return f"{self.x:{self.round_values_on_print}f}, {self.y:{self.round_values_on_print}f}"
 
     def __repr__(self:"V2|Vector2D") -> str:
-        return f"x:{self.x:.02f}\ty:{self.y:.02f}" if self.round_values_on_print else f"x:{self.x}\ty:{self.y}"
+        return f"x:{self.x:{self.round_values_on_print}f}\ty:{self.y:{self.round_values_on_print}f}"
 
     def __call__(self:"V2|Vector2D", return_tuple=False) -> list|tuple:
         return (self.x, self.y) if return_tuple else [self.x, self.y]
@@ -832,9 +784,8 @@ class Vector2D:
 
     # comparasion
     def __eq__(self, other) -> bool:
-        if not any(isinstance(other, cls) for cls in {Vector2D, V2, list, tuple}):
-            return False
-        other = self.__normalize__(other)
+        try: other = self.__normalize__(other)
+        except: return False
         return self.x == other.x and self.y == other.y
 
     def __ne__(self, other) -> bool:
@@ -904,7 +855,7 @@ class V2(Vector2D):
 
 V2inf = Vector2D(float('inf'), float('inf'))
 V2z = VectorZero = Vector2D()
-V2one = Vector2D(1, 1)
+V2one = Vector2D(1.0, 1.0)
 
 def rgb(r:float, g:float, b:float) -> tuple[float, float, float]:
     return (r,g,b)
@@ -934,7 +885,7 @@ def color_lerp(current_c:list|tuple, final_c:list|tuple, step:int|float=.1) -> t
         
     This will calculate the color at an interpolation step of 0.5 between (255, 0, 0) and (0, 0, 255).
     """
-    return tuple(c + (final_c[i] - c) * step for i,c in enumerate(current_c))
+    return tuple(c + (final_c[i] - c) * step for i,c in enumerate(current_c)) #type: ignore
 
 def color_fade(starting_c:list|tuple, final_c:list|tuple, index:int|float, max_index:int|float) -> tuple[float, float, float]:
     """
@@ -966,7 +917,7 @@ def color_fade(starting_c:list|tuple, final_c:list|tuple, index:int|float, max_i
             
         This will print the colors transitioning from (255, 0, 0) to (0, 0, 255).
     """
-    return tuple((starting_c[i] - final_c[i]) / max_index * (max_index - index) + final_c[i] for i in range(3))
+    return tuple((starting_c[i] - final_c[i]) / max_index * (max_index - index) + final_c[i] for i in range(3)) #type: ignore
 
 def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
     """
@@ -998,49 +949,7 @@ def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
     weights = colors_dict.values()
 
     if float("inf") in weights: return list(colors)[list(weights).index(float("inf"))]
-    return tuple(sum(n[i]*w for n,w in zip(colors, weights)) / sum(weights) for i in range(3))
-
-def angular_interpolation(starting_angle:int|float, final_angle:int|float, step:int|float=.1) -> float:
-    """
-    # Perform angular interpolation between two angles using the shortest distance.
-
-    ## Parameters:
-        starting_angle (int or float): The initial angle in radians.
-        final_angle (int or float): The target angle in radians to interpolate towards.
-        step (int or float, optional): The step size for interpolation in radians. Default is 0.1.
-
-    ## Returns:
-        float: The interpolated angle as a result of angular interpolation.
-
-    ## Example:
-        starting_angle = 1.0
-
-        final_angle = 5.0
-
-        interpolated_angle = angular_interpolation(starting_angle, final_angle)
-
-        print(f"Interpolated angle: {interpolated_angle}")
-
-        This will print the interpolated angle using angular interpolation.
-
-    ## Explanation:
-        The function calculates three distances between the `starting_angle` and the
-        `final_angle`. These distances represent possible angular interpolations:
-            1. The direct interpolation from `starting_angle` to `final_angle`.
-            2. The interpolation by taking a full circle (2 * pi) and then proceeding from
-               `starting_angle` to `final_angle`.
-            3. The interpolation by taking a full circle (2 * pi) in the opposite direction
-               and then proceeding from `starting_angle` to `final_angle`.
-
-        The function then chooses the shortest distance from the three options and returns
-        the interpolated angle obtained by multiplying the shortest distance by the `step`
-        value.
-
-        The `step` parameter controls the granularity of interpolation. Smaller `step` values
-        provide more fine-grained interpolation but may require more iterations.
-    """
-    distances = (final_angle - starting_angle, final_angle - DOUBLE_PI - starting_angle, final_angle + DOUBLE_PI - starting_angle)
-    return min(distances, key=abs) * step
+    return tuple(sum(n[i]*w for n,w in zip(colors, weights)) / sum(weights) for i in range(3)) #type: ignore
 
 def color_distance(starting_c:list|tuple, final_c:list|tuple, sqrd:bool=True) -> float:
     """
@@ -1084,6 +993,48 @@ def color_distance(starting_c:list|tuple, final_c:list|tuple, sqrd:bool=True) ->
     distance = sum([(starting_c[i]-final_c[i])**2 for i in range(3)])
     return (distance ** .5) if sqrd else distance
 
+def angular_interpolation(starting_angle:int|float, final_angle:int|float, step:int|float=.1) -> float:
+    """
+    # Perform angular interpolation between two angles using the shortest distance.
+
+    ## Parameters:
+        starting_angle (int or float): The initial angle in radians.
+        final_angle (int or float): The target angle in radians to interpolate towards.
+        step (int or float, optional): The step size for interpolation in radians. Default is 0.1.
+
+    ## Returns:
+        float: The interpolated angle as a result of angular interpolation.
+
+    ## Example:
+        starting_angle = 1.0
+
+        final_angle = 5.0
+
+        interpolated_angle = angular_interpolation(starting_angle, final_angle)
+
+        print(f"Interpolated angle: {interpolated_angle}")
+
+        This will print the interpolated angle using angular interpolation.
+
+    ## Explanation:
+        The function calculates three distances between the `starting_angle` and the
+        `final_angle`. These distances represent possible angular interpolations:
+            1. The direct interpolation from `starting_angle` to `final_angle`.
+            2. The interpolation by taking a full circle (2 * pi) and then proceeding from
+               `starting_angle` to `final_angle`.
+            3. The interpolation by taking a full circle (2 * pi) in the opposite direction
+               and then proceeding from `starting_angle` to `final_angle`.
+
+        The function then chooses the shortest distance from the three options and returns
+        the interpolated angle obtained by multiplying the shortest distance by the `step`
+        value.
+
+        The `step` parameter controls the granularity of interpolation. Smaller `step` values
+        provide more fine-grained interpolation but may require more iterations.
+    """
+    distances = (final_angle - starting_angle, final_angle - DOUBLE_PI - starting_angle, final_angle + DOUBLE_PI - starting_angle)
+    return min(distances, key=abs) * step
+
 def avg_position(*others:"Vector2D|V2") -> Vector2D|V2:
     """
     # Calculate the average position for a variable number of Vector2D others.

e2D/plots.py

@@ -13,6 +13,7 @@ class Function:
         self.plot : Plot
         self.color = color
         self.function = function
+        self.__layer_surface__ :pg.Surface= None #type: ignore
     
     def update_points(self) -> None:
         self.update_function(self.function)
@@ -82,7 +83,7 @@ class Function:
 class __PlotSettings__:
     def __init__(self, plot:Plot) -> None:
         self.plot = plot
-        self.settings :dict[str: bool|V2|Vector2D|int|float]= {
+        self.settings :dict= {
             "use_real_time_rendering" : True,
             "show_corners_coords" : True,
 
@@ -110,8 +111,9 @@ class __PlotSettings__:
     def print_current_settings(self) -> None:
         longest_key = max(map(len, self.settings))
         longest_type = max(map(lambda setting: len(str(type(setting)).split("'")[1]), self.settings.values()))
+        split_string = '"'
         for setting in self.settings:
-            print(f"{setting}{' '*(longest_key-len(setting))} :{str(type(self.settings[setting])).split("'")[1]}{' '*(longest_type-len(str(type(self.settings[setting])).split("'")[1]))}=\t{self.settings[setting]}")
+            print(f"{setting}{' '*(longest_key-len(setting))} :{str(type(self.settings[setting])).split(split_string)[1]}{' '*(longest_type-len(str(type(self.settings[setting])).split(split_string)[1]))}=\t{self.settings[setting]}")
     
     def set(self, key:str, new_value) -> None:
         if not (key in self.settings): raise ValueError(f"The key [{key}] does not exist...")
@@ -124,7 +126,7 @@ class __PlotSettings__:
     def get(self, key:str) -> bool|V2|Vector2D|int|float:
         return self.settings[key]
 
-    def multiple_set(self, keys:list[str]) -> list[bool|V2|Vector2D|int|float]:
+    def multiple_get(self, keys:list[str]) -> list[bool|V2|Vector2D|int|float]:
         return [self.get(key) for key in keys]
 
 class Plot:
@@ -182,19 +184,19 @@ class Plot:
         return (real_position - self.position) * (self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size + self.top_left_plot_coord
 
     def render(self) -> None:
-        self.canvas.fill(self.settings.get("bg_color"))
+        self.canvas.fill(self.settings.get("bg_color")) #type: ignore
         if self.top_left_x < 0 < self.bottom_right_x:
             pg.draw.line(self.canvas,
-                         self.settings.get("axes_default_color") if (x_color:=self.settings.get("x_axis_color"))==None else x_color,
+                         self.settings.get("axes_default_color") if (x_color:=self.settings.get("x_axis_color"))==None else x_color, #type: ignore
                          self.__plot2real__(V2(0, self.top_left_y))(),
                          self.__plot2real__(V2(0, self.bottom_right_y))(),
-                         self.settings.get("axes_default_width") if (x_width:=self.settings.get("x_axis_width"))==None else x_width)
+                         self.settings.get("axes_default_width") if (x_width:=self.settings.get("x_axis_width"))==None else x_width) #type: ignore
         if self.bottom_right_y < 0 < self.top_left_y:
             pg.draw.line(self.canvas,
-                         self.settings.get("axes_default_color") if (y_color:=self.settings.get("y_axis_color"))==None else y_color,
+                         self.settings.get("axes_default_color") if (y_color:=self.settings.get("y_axis_color"))==None else y_color, #type: ignore
                          self.__plot2real__(V2(self.top_left_x, 0))(),
                          self.__plot2real__(V2(self.bottom_right_x, 0))(),
-                         self.settings.get("axes_default_width") if (y_width:=self.settings.get("y_axis_width"))==None else y_width)
+                         self.settings.get("axes_default_width") if (y_width:=self.settings.get("y_axis_width"))==None else y_width) #type: ignore
 
         for function in self.functions: function.draw()
 
@@ -232,7 +234,7 @@ class Plot:
                 if event.type == pg.MOUSEWHEEL:
                     
                     range_n = self.settings.get("distance_to_axis_for_scalar_zoom")
-                    scalar = V2(0 if abs(self.plot_center_real_position.x - self.rootEnv.mouse.position.x) < range_n else 1, 0 if abs(self.plot_center_real_position.y - self.rootEnv.mouse.position.y) < range_n else 1)
+                    scalar = V2(0 if abs(self.plot_center_real_position.x - self.rootEnv.mouse.position.x) < range_n else 1, 0 if abs(self.plot_center_real_position.y - self.rootEnv.mouse.position.y) < range_n else 1) #type: ignore
                     self.current_zoom += event.y * scalar
 
                     self.update_grid(True)
@@ -259,14 +261,14 @@ class Plot:
     def draw(self) -> None:
         self.rootEnv.screen.blit(self.canvas, self.position())
         if self.is_mouse_in_rect and self.settings.get("show_cursor_coords"):
-            self.rootEnv.print(str(round(self.plot_mouse_position, .1)), self.rootEnv.mouse.position, fixed_sides=TEXT_FIXED_SIDES_BOTTOM_MIDDLE)
+            self.rootEnv.print(str(round(self.plot_mouse_position, .1)), self.rootEnv.mouse.position, fixed_sides=TEXT_FIXED_SIDES_BOTTOM_MIDDLE) #type: ignore
 
         data = [
             [f"ZOOM:", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
-            [f"  x: {self.current_zoom.x:.{self.settings.get("info_precision")}f};", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
-            [f"  y: {self.current_zoom.y:.{self.settings.get("info_precision")}f};", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
+            [f"  x: {self.current_zoom.x:.{self.settings.get('info_precision')}f};", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
+            [f"  y: {self.current_zoom.y:.{self.settings.get('info_precision')}f};", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
         ]
 
         for i, (d, fixed_side, show) in enumerate(data):
             if show:
-                self.rootEnv.print(d, self.settings.get("top_left_info_position") + self.settings.get("info_spacing") * i, fixed_sides=fixed_side)
+                self.rootEnv.print(d, self.settings.get("top_left_info_position") + self.settings.get("info_spacing") * i, fixed_sides=fixed_side) #type: ignore

{e2D-1.3.4.dist-info → e2D-1.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.3.4
+Version: 1.3.6
 Summary: Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!
 Home-page: https://github.com/marick-py/e2D
 Author: Riccardo Mariani

e2D-1.3.6.dist-info/RECORD

@@ -0,0 +1,9 @@
+e2D/__init__.py,sha256=7ew9vJekaWRt2oC3J7cqiKqHx0ya9pO-Em70UjlYYro,56780
+e2D/envs.py,sha256=mhq3SI2EmckXp9h6RYKzTGSKkvzlH-SyMTBhl3yDVZU,3929
+e2D/plots.py,sha256=leq6KUTaiIBQCYfn8ksOAd6Y8LKTbXutMDd9_SaCpJ4,15186
+e2D/utils.py,sha256=sq9efoNnSlJAfjvf18qDQpvO1jyz-9-mWBW3P4WMkD4,5368
+e2D-1.3.6.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
+e2D-1.3.6.dist-info/METADATA,sha256=-PcdAlDeFBdLOTjztw1DCVwcrLJwrFQDczcfx86x83k,9608
+e2D-1.3.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+e2D-1.3.6.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
+e2D-1.3.6.dist-info/RECORD,,

e2D-1.3.4.dist-info/RECORD

@@ -1,9 +0,0 @@
-e2D/__init__.py,sha256=1aJPqvWfZmIB_Ti7RaPX7KrHULha3VQe_ulsowcNqO8,58309
-e2D/envs.py,sha256=mhq3SI2EmckXp9h6RYKzTGSKkvzlH-SyMTBhl3yDVZU,3929
-e2D/plots.py,sha256=9vEmtbLJWEDkZwEHEgo9_6H0PBpeKX4ulPnvSPpN0eo,14997
-e2D/utils.py,sha256=sq9efoNnSlJAfjvf18qDQpvO1jyz-9-mWBW3P4WMkD4,5368
-e2D-1.3.4.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
-e2D-1.3.4.dist-info/METADATA,sha256=xdlbOBsa-MDr0b7PH-RXxZkrfdGaEtIBYsPON3IbJYQ,9608
-e2D-1.3.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-e2D-1.3.4.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
-e2D-1.3.4.dist-info/RECORD,,