diplotocus 0.0.0__py3-none-any.whl

diplotocus/core.py

@@ -0,0 +1,358 @@
+import numpy as np
+import subprocess,os,shlex,pickle
+import matplotlib.pyplot as plt
+import matplotlib
+import warnings
+from copy import deepcopy
+matplotlib.use("Agg")
+import shutil
+try:
+    has_ipython = True
+    from IPython.display import HTML, display
+except:
+    has_ipython = False
+    pass
+
+from .easings import *
+from .animations import *
+
+if shutil.which("ffmpeg") is None:
+    warnings.warn("FFmpeg is required to render videos, but is not installed. Please install it system-wide.")
+
+def in_notebook():
+    try:
+        from IPython import get_ipython
+        from IPython.display import HTML, display
+        shell = get_ipython().__class__.__name__
+        return shell == "ZMQInteractiveShell"
+    except Exception:
+        return False
+
+if in_notebook():
+    try:
+        from tqdm.notebook import tqdm
+        has_tqdm = True
+    except:
+        has_tqdm = False
+else:
+    try:
+        from tqdm import tqdm
+        has_tqdm = True
+    except:
+        has_tqdm = False
+
+def status_message(start_msg, end_msg):
+    if in_notebook():
+        from IPython.display import display, update_display, Markdown
+        display_id = display(Markdown(start_msg), display_id=True)
+        def update():
+            update_display(Markdown(end_msg), display_id=display_id.display_id)
+        return update
+    else:
+        print(start_msg, end="\r", flush=True)
+        def update():
+            print(end_msg + " " * max(0, len(start_msg) - len(end_msg)))
+        return update
+
+#----------------------------------------------
+# TIMELINE CLASS
+#----------------------------------------------
+
+def load_project(path):
+    tl = pickle.load(open(path, 'rb'))
+    animations = tl.animations
+    tl.x = 0
+    tl.clean_all()
+    return tl,animations
+
+class Timeline:
+    """Create and manage an animation timeline.
+
+    Parameters
+    ----------
+    name : str
+        the name used for the rendered images folder.
+    fig : Figure | None
+        an existing Figure to plot on. If None, a new Figure will be created.
+    quiet : bool
+        if True, any message will not be printed, and no progress bar will be shown.
+    dpi : int
+        The DPI of the rendered images (higher = better resolution/slower render).
+    transparent : bool
+        if True, the background color of the Figure and axes will be transparent. Can be used to render a transparent video (only compatible with a .mov video file).
+    axis_color : str
+        if True, changes the color of the axes, ticks and labels to the specified color.
+    noaxis : bool
+        if True, hides the axis lines, ticks and labels.
+    easing : easing
+        a global easing to be used if no other easing is specified on an animation.
+    xlim : tuple | None
+        if fig is None, sets the X limits of the created axis.
+    ylim : tuple | None
+        if fig is None, sets the Y limits of the created axis.
+    """
+    def __init__(self,
+                 name='Unnamed',
+                 fig=None,
+                 quiet=False,
+                 dpi=200,
+                 transparent=False,
+                 axis_color='k',
+                 noaxis=False,
+                 easing=easeLinear(),
+                 xlim=None,
+                 ylim=None,
+                 figsize=None
+        ):
+        if fig is None:
+            if figsize is not None:
+                fig,_ = plt.subplots(figsize=figsize)    
+            else:
+                fig,_ = plt.subplots()
+        self.fig = fig
+        self.ax = self.fig.get_axes()
+        if len(self.ax) == 1:
+            self.ax = self.ax[0]
+        else:
+            self.ax = np.array(self.ax)
+        if isinstance(self.ax,np.ndarray):
+            if isinstance(self.ax[0],np.ndarray):
+                self.main_axis = self.ax[0,0]
+            else:
+                self.main_axis = self.ax[0]
+        else:
+            self.main_axis = self.ax
+        if xlim is not None:
+            self.main_axis.set_xlim(*xlim)
+        if ylim is not None:
+            self.main_axis.set_ylim(*ylim)
+        self.name = name
+        self.quiet = quiet
+        self.dpi = dpi
+        self.easing = easing
+        self.x = 0
+        self.timeline_str = ''
+        self.transparent = transparent
+        self.animations = []
+        if in_notebook() == False:
+            namespace = sys._getframe(1).f_globals['__file__']
+            self.full_path = '/'.join(namespace.split('/')[:-1])
+        if axis_color != 'k':
+            self.set_axis_color(axis_color)
+        if noaxis:
+            self.main_axis.set_axis_off()
+
+    def set_axis_color(self,color):
+        if isinstance(self.ax,np.ndarray) == False:
+            axes = (self.ax,)
+        else:
+            axes = self.ax.flatten()
+        for axis in axes:
+            axis.spines['bottom'].set_color(color)
+            axis.spines['top'].set_color(color)
+            axis.spines['left'].set_color(color)
+            axis.spines['right'].set_color(color)
+            axis.xaxis.label.set_color(color)
+            axis.yaxis.label.set_color(color)
+            axis.tick_params(axis='both',colors=color)
+
+    def clean_all(self):
+        axes = np.ravel(self.ax)
+        for axis in axes:
+            for line in axis.lines:
+                line = np.ravel(line)
+                for l in line:
+                    if l.get_animated():
+                        l.remove()
+            for coll in axis.collections:
+                coll = np.ravel(coll)
+                for c in coll:
+                    if c.get_animated():
+                        c.remove()
+            for patch in axis.patches:
+                patch = np.ravel(patch)
+                for p in patch:
+                    if p.get_animated():
+                        p.remove()
+
+    def plot(self,animations,x=0,easing=None,debug=False):
+        if isinstance(animations,Animation):
+            animations = (animations,)
+
+        for animation in animations:
+            if animation.obj is not None and ((animation.x_min <= x < animation.x_max) or (x >= animation.x_max and animation.persistent == False)):
+                objects = np.ravel(animation.obj)
+                for obj in objects:
+                    try:
+                        obj.remove()
+                    except:
+                        pass
+            
+            animation.initialize(self)
+            #only plot if within an anim or if last one is persistent
+            last_anim = None
+            closest_dist = np.inf
+            for anim in animation.anims:
+                anim_x_max = anim['duration']+anim['delay']
+                if anim_x_max > x:
+                    continue
+                dist = x - anim_x_max
+                if dist < closest_dist:
+                    closest_dist = dist
+                    last_anim = anim
+            is_within_anim = False
+            if last_anim is not None:
+                is_within_anim = last_anim['persistent'] == True
+            if is_within_anim == False:
+                for anim in animation.anims:
+                    anim_x_min = anim['delay']
+                    anim_x_max = anim['duration']+anim['delay']
+                    if anim_x_min <= x < anim_x_max:
+                        is_within_anim = True
+                        break
+            if is_within_anim:
+                animation.apply(x,easing)
+        prev_x = self.x
+        self.x = x
+        self.save_plot(debug)
+        for animation in animations:
+            animation.clean(x,clear_anims=False)
+        self.x = prev_x
+
+    def animate(self,plot_objects,easing=None,debug=False):
+        """Render one or more plot objects into the timeline.
+
+        Parameters
+        ----------
+        plot_objects : Animation or sequence of Animation
+            a single plot object (e.g. `scatter`, `plot`, `hist`...) or a list of plot objects.
+        easing : easing
+            an easing override used while rendering.
+        debug : bool
+            if True, skip writing frame images to disk.
+        """
+        if isinstance(plot_objects,Animation):
+            plot_objects = (plot_objects,)
+        self.animations = deepcopy(np.array(plot_objects))
+        
+        x_max = 0
+        for animation in plot_objects:
+            for anim in animation.anims:
+                if anim['played'] == False:
+                    anim['delay'] += self.x
+            animation.initialize(self)
+
+            if animation.x_max > x_max:
+                x_max = animation.x_max
+        
+        loop = range(self.x,x_max)
+        if not self.quiet and has_tqdm:
+            loop = tqdm(loop)
+
+        for x in loop:
+            self.plot(animations=plot_objects,x=x,easing=easing,debug=debug)
+        for animation in plot_objects:
+            for anim in animation.anims:
+                anim['played'] = True
+        self.x = x_max
+
+    def wait(self,duration):
+        """Pause the animation for a number of frames.
+
+        Parameters
+        ----------
+        duration : int
+            the number of frames to pause the animation for.
+        """
+        if self.x == 0:
+            raise UserWarning('No rendered frames, run animate with animations to generate frames !')
+
+        last_frame = self.x - 1
+        source_png = self.name + '/' + self.name + '_{}.png'.format(last_frame)
+        for _ in range(duration):
+            target_png = self.name + '/' + self.name + '_{}.png'.format(self.x)
+            shutil.copyfile(source_png, target_png)
+            self.timeline_str += 'file \' ' + self.name + '_{}.png\'\n'.format(self.x)
+            self.timeline_str += 'duration {}\n'.format(1/30)
+            self.x += 1
+
+    def save_plot(self,debug):
+        if debug is False:
+            if os.path.isdir(self.name) == False:
+                os.makedirs(self.name)
+            fn = self.name + '/' + self.name +  '_{}.png'.format(self.x)
+            self.fig.savefig(fn,dpi=self.dpi,transparent=self.transparent)
+            
+            self.timeline_str += 'file \'' + self.name + '_{}.png\'\n'.format(self.x)
+            self.timeline_str += 'duration {}\n'.format(1/30)
+        self.x += 1
+    
+    def save_video(self,path=None,speed=1,ffmpeg_path='ffmpeg',multialpha=False,prerendered=False,clean=True):
+        """Render the current timeline to a video file.
+
+        Parameters
+        ----------
+        path : str | None
+            the path to save the video file to.
+        speed : float
+            by default, animations are rendered at 30fps (frames per second). You can change this by setting the speed. For 60fps videos, choose speed=2.
+        ffmpeg_path : str
+             if ffmpeg is not recognised as is, you can set the path to the ffmpeg executable through this parameter.
+        multialpha : bool
+            when rendering to a transparent .mov video, if you have semi-transparent frames, can be used to get better results.
+        prerendered : bool
+            if save_video() was already called and clean was set to False, image files and the text list file associated still exist. If you want to rerender the video, without having to rerender all the frames, you can set prerendered to true, which will only run the ffmpeg command.
+        clean : bool
+            if True, image files and the text list file associated are deleted after the video has been rendered.
+        """
+        if self.x == 0:
+            raise UserWarning('No rendered frames, run animate with animations to generate frames !')
+        if path is None:
+            if self.transparent:
+                path = self.name + '.mov'
+            else:
+                path = self.name + '.mp4'
+        video_fn = path
+        is_gif = video_fn.lower().endswith('.gif')
+        if not self.quiet:
+            update = status_message("Rendering video...", "Saved video " + video_fn)
+        if not prerendered:
+            self.timeline_str = ''
+            for i in range(self.x):
+                self.timeline_str += 'file \'' + self.name + '_{}.png\'\n'.format(i)
+                self.timeline_str += 'duration {}\n'.format(1/30/speed)
+            self.timeline_str += 'file \'' + self.name + '_{}.png\'\n'.format(i)
+            self.timeline_str += 'duration {}\n'.format(1/30/speed)
+            with open(self.name + '/' + self.name + '.txt','w+') as f:
+                f.write(self.timeline_str)
+        sequence_fn = self.name + '/' + self.name  + '.txt'
+
+        if '.mov' in video_fn:
+            if multialpha:
+                command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -vf premultiply=inplace=1 -c:v prores_ks -profile:v 4 -pix_fmt yuva444p10le -hide_banner -loglevel error {}'.format(sequence_fn,video_fn)
+            else:
+                command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -c:v prores -pix_fmt yuva444p10le -hide_banner -loglevel error {}'.format(sequence_fn,video_fn)
+        elif is_gif:
+            command = ffmpeg_path + ' -f concat -safe 0 -i {} -y -lavfi "split[s0][s1];[s0]palettegen=reserve_transparent=1:stats_mode=diff[p];[s1][p]paletteuse=dither=sierra2_4a:alpha_threshold=128" -gifflags -offsetting -loop 0 -hide_banner -loglevel error {}'.format(sequence_fn,video_fn)
+        else:
+            command = ffmpeg_path + ' -f concat -safe 0 -i {} -c:v libx264 -pix_fmt yuv420p -c:a aac -movflags +faststart -hide_banner -loglevel error -y {}'.format(sequence_fn,video_fn)
+        subprocess.run(shlex.split(command))
+        if clean:
+            shutil.rmtree(self.name)
+        plt.close()
+        if not self.quiet:
+            update()
+        
+        rand_id = np.random.randint(0,10_000)
+        if has_ipython:
+            if is_gif:
+                return display(HTML('<img src="{}?randId={}" style="max-width:640px;height:auto;" />'.format(video_fn,rand_id)))
+            return display(HTML("""
+                <video width="640" height="360" autoplay loop muted playsinline>
+                <source src="{}?randId={}" type="video/mp4">
+                </video>
+            """.format(video_fn,rand_id)))
+    
+    def save_project(self,path):
+        with open(path, 'wb') as f:
+            pickle.dump(self, f)

diplotocus/easings.py

@@ -0,0 +1,284 @@
+import numpy as np
+import sys, inspect
+#----------------------------------------------
+# EASING CLASSES
+#----------------------------------------------
+#TODO: add invert method to easing to behave in the inverted way so all inverted animations can work both ways
+#TODO: change plot of easings.ipynb like this : https://api.flutter.dev/flutter/animation/Curves/easeInBack-constant.html
+
+class Easing:
+    def __init__(self, func=None):
+        self.func = func if func is not None else (lambda x: x)
+    
+    def ease(self,x):
+        return self.func(x)
+    
+class easeCubicBezier(Easing):
+    def bezier(self, t, a1, a2):
+        return (
+            3 * (1 - t)**2 * t * a1
+            + 3 * (1 - t) * t**2 * a2
+            + t**3
+        )
+
+    def bezier_derivative(self, t, a1, a2):
+        return (
+            3 * (1 - t)**2 * a1
+            + 6 * (1 - t) * t * (a2 - a1)
+            + 3 * t**2 * (1 - a2)
+        )
+
+    def ease(self, times):
+        times = np.asarray(times, dtype=float)
+        times_clipped = np.clip(times, 0.0, 1.0)
+
+        # Initial guess: t ≈ x
+        t = times_clipped.copy()
+
+        # Newton–Raphson (vectorized)
+        for _ in range(self.max_iter):
+            x_t = self.bezier(t, self.x1, self.x2)
+            dx = x_t - times_clipped
+
+            if np.all(np.abs(dx) < self.epsilon):
+                break
+
+            dxd_t = self.bezier_derivative(t, self.x1, self.x2)
+            mask = np.abs(dxd_t) > 1e-8
+            if isinstance(t,np.ndarray):
+                t[mask] -= dx[mask] / dxd_t[mask]
+            else:
+                t -= dx[mask] / dxd_t[mask]
+
+            # Keep t in bounds
+            t = np.clip(t, 0.0, 1.0)
+
+        # Compute y(t)
+        y = self.bezier(t, self.y1, self.y2)
+
+        # Respect exact endpoints
+        if isinstance(y,np.ndarray):
+            y[times <= 0.0] = 0.0
+            y[times >= 1.0] = 1.0
+        else:
+            if times <= 0.0:
+                y = 0.0
+            elif times >= 1.0:
+                y = 1.0
+
+        if isinstance(y,np.ndarray) and len(y) == 1:
+            return y[0]
+        return y
+        
+
+    def __init__(self,x1,y1,x2,y2,epsilon=1e-6, max_iter=10):
+        self.x1 = x1
+        self.x2 = x2
+        self.y1 = y1
+        self.y2 = y2
+        self.epsilon = epsilon
+        self.max_iter = max_iter
+
+#LINEAR
+class easeLinear(Easing):
+    def __init__(self):
+        pass
+
+    def func(self,x):
+        return x
+
+# SINE
+class easeInSine(Easing):
+    def __init__(self):
+        super().__init__(lambda x:1 - np.cos((x * np.pi) / 2))
+
+class easeOutSine(Easing):
+    def __init__(self):
+        super().__init__(lambda x: np.sin((x * np.pi) / 2))
+
+class easeInOutSine(Easing):
+    def __init__(self):
+        super().__init__(lambda x: -(np.cos(np.pi * x) - 1) / 2)
+
+# QUADRATIC
+class easeInQuad(Easing):
+    def __init__(self):
+        super().__init__(lambda x: x**2)
+
+class easeOutQuad(Easing):
+    def __init__(self):
+        super().__init__(lambda x: 1 - (1-x)**2)
+
+class easeInOutQuad(Easing):
+    def __init__(self):
+        super().__init__(lambda x: np.where(x<0.5,2*x**2,1-(-2*x+2)**2 / 2))
+
+# SUBIC
+class easeInCubic(Easing):
+    def __init__(self):
+        super().__init__(lambda x: x**3)
+
+class easeOutCubic(Easing):
+    def __init__(self):
+        super().__init__(lambda x: 1 - (1-x)**3)
+
+class easeInOutCubic(Easing):
+    def __init__(self):
+        super().__init__(lambda x: np.where(x<0.5,4*x**3,1-(-2*x+2)**3 / 2))
+
+# QUARTIC
+class easeInQuart(Easing):
+    def __init__(self):
+        super().__init__(lambda x: x**4)
+
+class easeOutQuart(Easing):
+    def __init__(self):
+        super().__init__(lambda x: 1-(1-x)**4)
+
+class easeInOutQuart(Easing):
+    def __init__(self):
+        super().__init__(lambda x:np.where(x<0.5,8*x**4,1-(-2*x+2)**4 / 2))
+
+# QUINTIC
+class easeInQuint(Easing):
+    def __init__(self):
+        super().__init__(lambda x: x**5)
+
+class easeOutQuint(Easing):
+    def __init__(self):
+        super().__init__(lambda x: 1-(1-x)**5)
+
+class easeInOutQuint(Easing):
+    def __init__(self):
+        super().__init__(lambda x:np.where(x<0.5,16*x**5,1-(-2*x+2)**5 / 2))
+
+# EXPONENTIAL
+class easeInExpo(Easing):
+    def __init__(self):
+        super().__init__(lambda x:np.where(x==0,0,2**(10*x-10)))
+
+class easeOutExpo(Easing):
+    def __init__(self):
+        super().__init__(lambda x:np.where(x==1,1,1-2**(-10*x)))
+
+class easeInOutExpo(Easing):
+    def __init__(self):
+        super().__init__(lambda x:np.where(x==0,0,np.where(x==1,1,np.where(x<0.5,2**(20*x-10) / 2,(2-2**(-20*x+10)) / 2))))
+
+# CIRCLE
+class easeInCirc(Easing):
+    def __init__(self):
+        super().__init__(lambda x: 1 - np.sqrt(1 - x**2))
+
+class easeOutCirc(Easing):
+    def __init__(self):
+        super().__init__(lambda x: np.sqrt(1 - (x - 1)**2))
+
+class easeInOutCirc(Easing):
+    def __init__(self):
+        #(Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2
+        #(np.sqrt(1 - (-2*x)**2) + 1) / 2
+        super().__init__(lambda x:np.where(
+            x<0.5,
+            (1 - np.sqrt(np.abs(1 - (2*x)**2))) / 2,
+            (np.sqrt(np.abs(1 - (-2*x+2)**2)) + 1) / 2)
+        )
+
+# BACK
+class easeInBack(Easing):
+    def __init__(self):
+        def func(x):
+            c1 = 1.70158
+            c3 = c1 + 1
+
+            return c3 * x * x * x - c1 * x * x
+        super().__init__(func)
+
+class easeOutBack(Easing):
+    def __init__(self):
+        def func(x):
+            c1 = 1.70158
+            c3 = c1 + 1
+
+            return 1 + c3 * (x - 1)**3 + c1 * (x - 1)**2
+        super().__init__(func)
+
+class easeInOutBack(Easing):
+    def __init__(self):
+        def func(x):
+            c1 = 1.70158
+            c2 = c1 * 1.525
+
+            return np.where(x < 0.5,
+                ((2 * x)**2 * ((c2 + 1) * 2 * x - c2)) / 2,
+                ((2 * x - 2)**2 * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2
+            )
+        super().__init__(func)
+
+# ELASTIC
+class easeInElastic(Easing):
+    def __init__(self):
+        def func(x):
+            c4 = (2 * np.pi) / 3
+
+            return np.where(x == 0,0,np.where(x == 1,1,
+                -2**(10 * x - 10) * np.sin((x * 10 - 10.75) * c4)
+            ))
+        super().__init__(func)
+
+class easeOutElastic(Easing):
+    def __init__(self):
+        def func(x):
+            c4 = (2 * np.pi) / 3
+
+            return np.where(x == 0,0,np.where(x == 1,1,
+                2**(-10 * x) * np.sin((x * 10 - 0.75) * c4) + 1
+            ))
+        super().__init__(func)
+
+class easeInOutElastic(Easing):
+    def __init__(self):
+        def func(x):
+            c5 = (2 * np.pi) / 4.5
+
+            return np.where(x == 0,0,np.where(x == 1,1,np.where(x<0.5,
+                -(2**(20 * x - 10) * np.sin((20 * x - 11.125) * c5)) / 2,
+                (2**(-20 * x + 10) * np.sin((20 * x - 11.125) * c5)) / 2 + 1
+            )))
+        super().__init__(func)
+
+# BOUNCE
+def outBounce(x):
+    n1 = 7.5625
+    d1 = 2.75
+
+    return np.where(x < 1 / d1,
+        n1 * x * x,
+    np.where(x < 2 / d1,
+        n1 * (x - 1.5 / d1) * (x - 1.5 / d1) + 0.75,
+    np.where(x < 2.5 / d1,
+        n1 * (x - 2.25 / d1) * (x - 2.25 / d1) + 0.9375,
+        n1 * (x - 2.625 / d1) * (x - 2.625 / d1) + 0.984375
+    )))
+
+class easeOutBounce(Easing):
+    def __init__(self):
+        super().__init__(outBounce)
+
+class easeInBounce(Easing):
+    def __init__(self):
+        def func(x):
+            x = 1-x
+            return 1-outBounce(x)
+        super().__init__(func)
+
+class easeInOutBounce(Easing):
+    def __init__(self):
+        def func(x):
+            return np.where(x<0.5,(1 - outBounce(1 - 2 * x)) / 2,(1 + outBounce(2 * x - 1)) / 2)
+        super().__init__(func)
+
+available_easings = []
+for name, obj in inspect.getmembers(sys.modules[__name__]):
+    if inspect.isclass(obj) and name != 'Easing':
+        available_easings.append(name)

diplotocus-0.0.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: diplotocus
+Version: 0.0.0
+Summary: A python package to generate animations of matplotlib objects.
+Author-email: Tristan Boin <tristan.boin@obspm.fr>
+License-Expression: MIT
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Matplotlib
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: svgpath2mpl
+Dynamic: license-file

diplotocus-0.0.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+diplotocus/__init__.py,sha256=57u1-7-LURrHkFfv_ZxrsxjD69j4AJFQ56GDR9Ii2mY,111
+diplotocus/_version.py,sha256=rqyZtt1djmoU2vxYGslRgV4TaBWrxK8uesP_Xai_8-U,19
+diplotocus/animations.py,sha256=Bnbc7O8MnSscYKNSxfwlyDCaQLI6CLQqj1v_Kq0NIpA,138717
+diplotocus/core.py,sha256=ITDigZA78T4vOYz1pCP9Eksm2DvgKQ_FP_rKQy8Z0DM,14019
+diplotocus/easings.py,sha256=zhwPItn_YnOczCX5czOQ3H47rJ0-qY3nsx3Gbgt8PNc,7798
+diplotocus/GUI/GUI.html,sha256=r62SAu4Q_HM1vg04P0l1-rpWFulZ1DVypyO9uvfAA_k,7096
+diplotocus/GUI/__init__.py,sha256=lKTP_zNmcPE__OcOD9QniK7h6nLZ7U93b9Izo6oxtc8,42
+diplotocus/GUI/app.js,sha256=x_sZiaQCnKDe8IyN8RbU8qKUODDpi7EpgeXnmtidCec,50053
+diplotocus/GUI/server.py,sha256=cHC1cbTW_wSnH4_42jL2W-OjptgE2MOJlZb2APn52SI,56039
+diplotocus/GUI/style.css,sha256=rT__vQuB20q1PZywP8te0DV917H9AQHwJclBg4elqY0,10824
+diplotocus/GUI/src/bg.png,sha256=ySX6slK8Ddlg7V16fOeAJxWuVT9i3_Dub-wsT5Y1ZqI,64165
+diplotocus/GUI/src/favicon.ico,sha256=7sz7EfCWA-cba-_z_1jO7Ik2VY24K1VvubgEPli-1I4,11643
+diplotocus/GUI/src/logo_bg.png,sha256=SrlSmKGQ8-O2quENjM16NFq2RjtYtbU7YH_c_bO27h8,33131
+diplotocus/GUI/src/btn/btn_bg_Draw.png,sha256=PUG13hBQpFdd5mQsmB_wD6sigWC7HDi-npJVBwNIn34,34804
+diplotocus/GUI/src/btn/btn_bg_Morph.png,sha256=QgLIpy7P4lidTVQQ32kivqndBgNU9cZPYNmgTixtxKo,35437
+diplotocus/GUI/src/btn/btn_bg_Rotate.png,sha256=Sqji90eWk8oRHRjvm1a2qez07c0AuAL4sRMr6cWJows,35000
+diplotocus/GUI/src/btn/btn_bg_Scale.png,sha256=VgykxIa4RJ_2bfISLU3rYvJ7yy95NQ91VMndpDe7JvU,35441
+diplotocus/GUI/src/btn/btn_bg_Sequence.png,sha256=Z7yQytDrtwaNfHL5Sazt3AFIWHBE7mOQ2qYocg0oCOo,36230
+diplotocus/GUI/src/btn/btn_bg_Translate.png,sha256=RVrUq2RwnVLWj0SzoE-NnZeLJHwfvkeoLfUdeWBFmm8,35179
+diplotocus/GUI/src/btn/btn_bg_Tween.png,sha256=IjtpQqIQP8ePltwPJ2zqKBQooobI47Ojczi0PSSbSWo,34926
+diplotocus/GUI/src/btn/btn_bg_default.png,sha256=QfrqN7N8c5TRgtBfU3Pw01tU5KfxyKihFXy5R9VrQsw,33705
+diplotocus-0.0.0.dist-info/licenses/LICENSE,sha256=s8eQhVWRZLr1lA8akzj1JW1RiWTocDzEpUfKzSARYvU,1072
+diplotocus-0.0.0.dist-info/METADATA,sha256=g9GeD3mWF2e5OpPQwUgT58s3AyHJC5KEUMQHhzDGjts,540
+diplotocus-0.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+diplotocus-0.0.0.dist-info/top_level.txt,sha256=0nwg4ncIvxlo7OPlygJSE2zdUYFkV87w8a2-wRzhIhg,11
+diplotocus-0.0.0.dist-info/RECORD,,

diplotocus-0.0.0.dist-info/WHEEL

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