diplotocus 0.0.1__py3-none-any.whl

diplotocus/__init__.py

@@ -0,0 +1,3 @@
+from ._version import __version__
+from .core import *
+import diplotocus.easings as easings

diplotocus/_version.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

diplotocus/animations.py

@@ -0,0 +1,599 @@
+import numpy as np
+
+#----------------------------------------------
+# ANIMATION CLASSES
+#----------------------------------------------
+
+class Animation:
+    def __init__(self,duration,delay=0,easing=None,axis=None,**kwargs):
+        self.anim_function = None
+        self.delay = delay
+        self.duration = duration
+        self.set_easing(easing)
+        self.compute_timings()
+        self.set_axis(axis)
+        self.anim_type = 'show'
+        self.obj = None
+        kwargs = self.clean_kwargs(kwargs)
+        self.kwargs = kwargs
+        self.anim_function = self.function
+
+    def set_axis(self,axis):
+        self.axis = axis
+        return self
+
+    def compute_timings(self):
+        self.x_min = self.delay
+        self.x_max = self.duration + self.delay
+
+    def set_duration(self,duration):
+        self.duration = duration
+        self.compute_timings()
+        return self
+
+    def set_delay(self,delay):
+        self.delay = delay
+        self.compute_timings()
+        return self
+
+    def set_easing(self,easing):
+        self.easing = easing
+        return self
+
+    def apply(self,x):
+        if x < self.x_min or x >= self.x_max:
+            return
+        if self.duration == 1:
+            self.anim_function(1)
+            return
+        t = self.easing.ease((x-self.delay)/(self.duration-1))
+        self.anim_function(t)
+
+    def initialize(self):
+        self.clean(0)
+
+    def show(self):
+        self.anim_type = 'show'
+        return self
+
+    def hide(self,delay=0,duration=None):
+        self.anim_type = 'hide'
+        self.set_delay(delay)
+        if duration is not None:
+            self.set_duration(duration)
+        return self
+    
+    def spawn(self):
+        self.anim_type = 'spawn'
+        return self
+    
+    def despawn(self,delay=0,duration=None):
+        self.anim_type = 'despawn'
+        self.set_delay(delay)
+        if duration is not None:
+            self.set_duration(duration)
+        return self
+    
+    def grow(self):
+        self.anim_type = 'grow'
+        return self
+    
+    def shrink(self,delay=0,duration=None):
+        self.anim_type = 'shrink'
+        self.set_delay(delay)
+        if duration is not None:
+            self.set_duration(duration)
+        return self
+    
+    def update(self):
+        self.anim_type = 'update'
+        return self
+    
+    def deupdate(self):
+        self.anim_type = 'deupdate'
+        return self
+    
+    def morph(self,new_x,new_y,new_alpha=None):
+        self.new_x = new_x
+        self.new_y = new_y
+        self.new_alpha = new_alpha
+        self.anim_type = 'morph'
+        return self
+    
+    def demorph(self):
+        self.anim_type = 'demorph'
+        return self
+    
+    def reverse(self,delay=0,duration=None):
+        self.set_delay(delay)
+        if duration is not None:
+            self.set_duration(duration)
+        return self
+    
+    def clean(self,x):
+        if x >= self.x_min-1 and x < self.x_max-1 and self.obj is not None:
+            if isinstance(self.obj,list):
+                for obj in self.obj:
+                    obj.remove()
+            else:
+                self.obj.remove()
+            self.obj = None
+
+    def clean_kwargs(self,kwargs):
+        if 'duration' in kwargs:
+            del kwargs['duration']
+        if 'delay' in kwargs:
+            del kwargs['delay']
+        if 'easing' in kwargs:
+            del kwargs['delay']
+        if 'axis' in kwargs:
+            del kwargs['axis']
+        return kwargs
+
+class zoom(Animation):
+    def __init__(self,zoom, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.zoom = 1/zoom
+
+    def reverse(self):
+        super().reverse()
+        self.zoom = 1/self.zoom
+        return self
+
+    def initialize(self):
+        self.width_init  = self.axis.get_xlim()[1]-self.axis.get_xlim()[0]
+        self.height_init = self.axis.get_ylim()[1]-self.axis.get_ylim()[0]
+        self.width_end = self.width_init * self.zoom
+        self.height_end = self.height_init * self.zoom
+
+    def function(self,t):
+        center = ((self.axis.get_xlim()[1]+self.axis.get_xlim()[0])/2,(self.axis.get_ylim()[1]+self.axis.get_ylim()[0])/2)
+        width = self.width_init + (self.width_end - self.width_init)*t
+        height = self.height_init + (self.height_end - self.height_init)*t
+        x_range = (center[0] - width/2, center[0] + width/2)
+        y_range = (center[1] - height/2, center[1] + height/2)
+        self.axis.set_xlim(x_range[0],x_range[1])
+        self.axis.set_ylim(y_range[0],y_range[1])
+
+class lims(Animation):
+    def __init__(self,xlim=None,ylim=None, *args, **kwargs):
+        if xlim is None and ylim is None:
+            raise ValueError('Both xlim and ylim cannot be empty.')
+        super().__init__(*args, **kwargs)
+        self.xlim = xlim
+        self.ylim = ylim
+
+    def initialize(self):
+        self.xlim_init = self.axis.get_xlim()
+        self.ylim_init = self.axis.get_ylim()
+        if self.xlim is not None:
+            self.xlim_end = self.xlim
+        else:
+            self.xlim_end = self.xlim_init
+        if self.ylim is not None:
+            self.ylim_end = self.ylim
+        else:
+            self.ylim_end = self.ylim_init
+
+    def function(self,t):
+        xlim_left   = self.xlim_init[0] + (self.xlim_end[0] - self.xlim_init[0])*t
+        xlim_right  = self.xlim_init[1] + (self.xlim_end[1] - self.xlim_init[1])*t
+        ylim_bottom = self.ylim_init[0] + (self.ylim_end[0] - self.ylim_init[0])*t
+        ylim_top    = self.ylim_init[1] + (self.ylim_end[1] - self.ylim_init[1])*t
+        self.axis.set_xlim(xlim_left,xlim_right)
+        self.axis.set_ylim(ylim_bottom,ylim_top)
+
+class move(Animation):
+    def __init__(self,pos, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.pos = pos
+        self.anim_function = self.function
+
+    def reverse(self):
+        super().reverse()
+        self.pos = self.pos_init
+        return self
+
+    def initialize(self):
+        width  = self.axis.get_xlim()[1]-self.axis.get_xlim()[0]
+        height = self.axis.get_ylim()[1]-self.axis.get_ylim()[0]
+        self.pos_init = (self.axis.get_xlim()[0]+width/2,self.axis.get_ylim()[0]+height/2)
+        self.pos_end = self.pos
+
+    def function(self,t):
+        width  = self.axis.get_xlim()[1]-self.axis.get_xlim()[0]
+        height = self.axis.get_ylim()[1]-self.axis.get_ylim()[0]
+        pos_x = self.pos_init[0] + (self.pos_end[0] - self.pos_init[0])*t
+        pos_y = self.pos_init[1] + (self.pos_end[1] - self.pos_init[1])*t
+        self.axis.set_xlim(pos_x-width/2,pos_x+width/2)
+        self.axis.set_ylim(pos_y-height/2,pos_y+height/2)
+
+class scatter(Animation):
+    def __init__(self,x,y, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.x = x
+        self.y = y
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+            x = self.x
+            y = self.y
+        elif self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+            x = self.x
+            y = self.y
+        elif self.anim_type == 'spawn':
+            i_max = min(round(t*len(self.x)) + 1,len(self.x))
+            x = self.x[:i_max]
+            y = self.y[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'despawn':
+            i_max = max(round((1-t)*len(self.x)),0)
+            x = self.x[:i_max]
+            y = self.y[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'morph':
+            x = []
+            y = []
+            a = []
+            if 'alpha' not in kwargs:
+                kwargs['alpha'] = 1
+            for i in range(len(self.x)):
+                x.append(self.x[i] + (self.new_x[i] - self.x[i])*t)
+                y.append(self.y[i] + (self.new_y[i] - self.y[i])*t)
+                if self.new_alpha is not None:
+                    a.append(kwargs['alpha'] + (self.new_alpha[i] - kwargs['alpha'])*t)
+                else:
+                    a.append(kwargs['alpha'])
+            kwargs['alpha'] = a
+        elif self.anim_type == 'demorph':
+            x = []
+            y = []
+            a = []
+            if 'alpha' not in kwargs:
+                kwargs['alpha'] = 1
+            for i in range(len(self.x)):
+                x.append(self.x[i] + (self.new_x[i] - self.x[i])*(1-t))
+                y.append(self.y[i] + (self.new_y[i] - self.y[i])*(1-t))
+                if self.new_alpha is not None:
+                    a.append(kwargs['alpha'] + (self.new_alpha[i] - kwargs['alpha'])*t)
+                else:
+                    a.append(kwargs['alpha'])
+            kwargs['alpha'] = a
+        
+        self.obj = self.axis.scatter(x,y,**kwargs)
+
+class plot(Animation):
+    def __init__(self,x,y, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.new_x = None
+        self.new_y = None
+        self.x = x
+        self.y = y
+
+    def clean(self,x):
+        super().clean(x)
+        if x == self.x_max-1 and self.new_x is not None:
+            self.x = self.new_x
+            self.y = self.new_y
+            self.new_x = None
+            self.new_y = None
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+            x = self.x
+            y = self.y
+        elif self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+            x = self.x
+            y = self.y
+        elif self.anim_type == 'spawn':
+            i_max = min(round(t*len(self.x)) + 1,len(self.x))
+            x = self.x[:i_max]
+            y = self.y[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'despawn':
+            i_max = max(round((1-t)*len(self.x)),0)
+            x = self.x[:i_max]
+            y = self.y[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'morph':
+            x = []
+            y = []
+            for i in range(len(self.x)):
+                x.append(self.x[i] + (self.new_x[i] - self.x[i])*t)
+                y.append(self.y[i] + (self.new_y[i] - self.y[i])*t)
+        elif self.anim_type == 'demorph':
+            x = []
+            y = []
+            for i in range(len(self.x)):
+                x.append(self.x[i] + (self.new_x[i] - self.x[i])*(1-t))
+                y.append(self.y[i] + (self.new_y[i] - self.y[i])*(1-t))
+        
+        self.obj = self.axis.plot(x,y,**kwargs)
+
+class fill_between(Animation):
+    def __init__(self,x,y1,y2, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.x = np.array(x)
+        self.y1 = np.array(y1).reshape(-1)
+        self.y2 = np.array(y2).reshape(-1)
+        if self.y1.size != self.x.size:
+            self.y1 = np.ones_like(self.x)*self.y1[0]
+        if self.y2.size != self.x.size:
+            self.y2 = np.ones_like(self.x)*self.y2[0]
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+            x = self.x
+            y1 = self.y1
+            y2 = self.y2
+        elif self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+            x = self.x
+            y1 = self.y1
+            y2 = self.y2
+        elif self.anim_type == 'spawn':
+            i_max = min(round(t*len(self.x)) + 1,len(self.x))
+            x = self.x[:i_max]
+            y1 = self.y1[:i_max]
+            y2 = self.y2[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'despawn':
+            i_max = max(round((1-t)*len(self.x)),0)
+            x = self.x[:i_max]
+            y1 = self.y1[:i_max]
+            y2 = self.y2[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'grow':
+            widths = self.y2 - self.y1
+            centers = (self.y2 + self.y1)/2
+            x = self.x
+            y1 = centers - t*widths/2
+            y2 = centers + t*widths/2
+        elif self.anim_type == 'shrink':
+            widths = self.y2 - self.y1
+            centers = (self.y2 + self.y1)/2
+            x = self.x
+            y1 = centers - (1-t)*widths/2
+            y2 = centers + (1-t)*widths/2
+        
+        self.obj = self.axis.fill_between(x=x,y1=y1,y2=y2,**kwargs)
+
+class fill_betweenx(Animation):
+    def __init__(self,y,x1,x2, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.y = np.array(y)
+        self.x1 = np.array(x1).reshape(-1)
+        self.x2 = np.array(x2).reshape(-1)
+        if self.x1.size != self.y.size:
+            self.x1 = np.ones_like(self.y[0])*self.x1[0]
+        if self.x2.size != self.y.size:
+            self.x2 = np.ones_like(self.y[0])*self.x2[0]
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+            y = self.y
+            x1 = self.x1
+            x2 = self.x2
+        elif self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+            y = self.y
+            x1 = self.x1
+            x2 = self.x2
+        elif self.anim_type == 'spawn':
+            i_max = min(round(t*len(self.y)) + 1,len(self.y))
+            y = self.y[:i_max]
+            x1 = self.x1[:i_max]
+            x2 = self.x2[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'despawn':
+            i_max = max(round((1-t)*len(self.y)),0)
+            y = self.y[:i_max]
+            x1 = self.x1[:i_max]
+            x2 = self.x2[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'grow':
+            widths = self.x2 - self.x1
+            centers = (self.x2 + self.x1)/2
+            y = self.y
+            x1 = centers - t*widths/2
+            x2 = centers + t*widths/2
+        elif self.anim_type == 'shrink':
+            widths = self.x2 - self.x1
+            centers = (self.x2 + self.x1)/2
+            y = self.y
+            x1 = centers - (1-t)*widths/2
+            x2 = centers + (1-t)*widths/2
+        
+        self.obj = self.axis.fill_betweenx(y=y,x1=x1,x2=x2,**kwargs)
+
+class axvline(Animation):
+    def __init__(self,x, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.x = x
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+        x = self.x
+        y_max = 1
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+        elif self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+        elif self.anim_type == 'spawn':
+            y_max = t
+        elif self.anim_type == 'despawn':
+            y_max = (1-t)
+
+        self.obj = self.axis.axvline(x,ymin=0,ymax=y_max,**kwargs)
+
+class errorbar(Animation):
+    def __init__(self,x,y,xerr=None,yerr=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.x = x
+        self.y = y
+        if xerr is None:
+            xerr = np.zeros_like(x)
+        if yerr is None:
+            yerr = np.zeros_like(y)
+        self.xerr = xerr
+        self.yerr = yerr
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+            x = self.x
+            y = self.y
+            xerr = self.xerr
+            yerr = self.yerr
+        elif self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+            x = self.x
+            y = self.y
+            xerr = self.xerr
+            yerr = self.yerr
+        elif self.anim_type == 'spawn':
+            i_max = min(round(t*len(self.x)) + 1,len(self.x))
+            x = self.x[:i_max]
+            y = self.y[:i_max]
+            xerr = self.xerr[:i_max]
+            yerr = self.yerr[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        elif self.anim_type == 'despawn':
+            i_max = max(round((1-t)*len(self.x)),0)
+            x = self.x[:i_max]
+            y = self.y[:i_max]
+            xerr = self.xerr[:i_max]
+            yerr = self.yerr[:i_max]
+            if 'c' in kwargs:
+                kwargs['c'] = kwargs['c'][:i_max]
+        
+        self.obj = self.axis.errorbar(x,y,xerr=xerr,yerr=yerr,**kwargs)
+
+class hist(Animation):
+    def __init__(self,x,bins=None,range=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.x = x
+        self.bins = bins
+        self.range = range
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+        if self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+        if self.anim_type == 'spawn':
+            i_max = min(round(t*len(self.x)) + 1,len(self.x))
+        elif self.anim_type == 'despawn':
+            i_max = max(round((1-t)*len(self.x)),0)
+        x = self.x[:i_max]
+        h,edges,self.obj = self.axis.hist(x,bins=self.bins,range=self.range,**kwargs)
+
+class hist2d(Animation):
+    def __init__(self,x,y,bins=None,range=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.x = x
+        self.y = y
+        self.bins = bins
+        self.range = range
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+            i_max = len(self.x)
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+        if self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+        elif self.anim_type == 'spawn':
+            i_max = min(round(t*len(self.x)) + 1,len(self.x))
+        elif self.anim_type == 'despawn':
+            i_max = max(round((1-t)*len(self.x)),0)
+        x = self.x[:i_max]
+        y = self.y[:i_max]
+        old_xlim = self.axis.get_xlim()
+        old_ylim = self.axis.get_ylim()
+        h,xedges,yedges,self.obj = self.axis.hist2d(x,y,bins=self.bins,range=self.range,**kwargs)
+        self.axis.set_xlim(old_xlim)
+        self.axis.set_ylim(old_ylim)
+
+class contourf(Animation):
+    def __init__(self,z,levels=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.z = z
+        self.levels = levels
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+        elif self.anim_type == 'hide':
+            kwargs['alpha'] *= (1-t)
+        old_xlim = self.axis.get_xlim()
+        old_ylim = self.axis.get_ylim()
+        self.obj = self.axis.contourf(self.z,levels=self.levels,**kwargs)
+        self.axis.set_xlim(old_xlim)
+        self.axis.set_ylim(old_ylim)
+
+class text(Animation):
+    def __init__(self,x,y,string, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.x = x
+        self.y = y
+        self.string = string
+        if isinstance(self.string,str):
+            self.string = np.array(self.string).reshape(-1)
+    
+    def function(self,t):
+        kwargs = self.kwargs.copy()
+        if 'alpha' not in kwargs:
+            kwargs['alpha'] = 1
+        if self.anim_type == 'show':
+            kwargs['alpha'] *= t
+            s = self.string[0]
+        elif self.anim_type == 'hide':
+            kwargs['alpha'] *= 1-t
+            s = self.string[0]
+        elif self.anim_type == 'update':
+            i = min(round(t*len(self.string)) + 1,len(self.string))
+            s = self.string[i]
+        elif self.anim_type == 'deupdate':
+            i = max(round((1-t)*len(self.string)),0)
+            s = self.string[i]
+
+        self.obj = self.axis.text(x=self.x,y=self.y,s=s,**kwargs)

diplotocus/core.py

@@ -0,0 +1,173 @@
+import numpy as np
+import subprocess,os,shlex,io,pickle
+import matplotlib.pyplot as plt
+import shutil
+
+from .easings import *
+from .animations import *
+
+def in_notebook():
+    try:
+        from IPython import get_ipython
+        shell = get_ipython().__class__.__name__
+        return shell == "ZMQInteractiveShell"
+    except Exception:
+        return False
+    
+if in_notebook():
+    from tqdm.notebook import tqdm
+else:
+    from tqdm import tqdm
+
+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
+
+#----------------------------------------------
+# SEQUENCE CLASS
+#----------------------------------------------
+
+class Sequence:
+    def __init__(self,fig,name,tqdm=True,dpi=200,easing=easeLinear()):
+        #buf = io.BytesIO()
+        #pickle.dump(fig, buf)
+        #buf.seek(0)
+        #self.fig = pickle.load(buf) 
+        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
+        self.name = name
+        self.tqdm = tqdm
+        self.dpi = dpi
+        self.easing = easing
+        self.x = 0
+        self.sequence_str = ''
+        self.set_white()
+
+    def set_white(self):
+        if isinstance(self.ax,np.ndarray) == False:
+            axes = (self.ax,)
+        else:
+            axes = self.ax.flatten()
+        for axis in axes:
+            axis.spines['bottom'].set_color('white')
+            axis.spines['top'].set_color('white')
+            axis.spines['left'].set_color('white')
+            axis.spines['right'].set_color('white')
+            axis.xaxis.label.set_color('white')
+            axis.yaxis.label.set_color('white')
+            axis.tick_params(axis='both',colors='white')
+
+    def plot(self,animations,easing=None,debug=False):
+        if isinstance(animations,Animation):
+            animations = (animations,)
+        for animation in animations:
+            if animation.axis is None:
+                animation.set_axis(self.main_axis)
+            animation.initialize()
+            if animation.easing == None:
+                if easing is None:
+                    animation.easing = self.easing
+                else:
+                    animation.easing = easing
+            animation.apply(animation.x_max-1)
+        self.save_plot(debug)
+
+    def animate(self,animations,easing=None,debug=False):
+        if isinstance(animations,Animation):
+            animations = (animations,)
+        x_max = 0
+        for animation in animations:
+            if animation.axis is None:
+                animation.set_axis(self.main_axis)
+            animation.initialize()
+            if animation.easing == None:
+                if easing is None:
+                    animation.easing = self.easing
+                else:
+                    animation.easing = easing
+
+            if animation.x_max > x_max:
+                x_max = animation.x_max
+        
+        loop = range(x_max)
+        if self.tqdm:
+            loop = tqdm(loop)
+
+        for x in loop:
+            for animation in animations:
+                animation.apply(x)
+            self.save_plot(debug)
+            for animation in animations:
+                animation.clean(x)
+        
+    def wait(self,duration):
+        #Have to do in two steps, because doesn't work in 1 if wait is the last animation of the sequence
+        self.sequence_str += 'file \'' + self.name + '_{}.png\'\n'.format(self.x - 1)
+        self.sequence_str += 'duration {}\n'.format((duration-1)/30)
+        self.sequence_str += 'file \'' + self.name + '_{}.png\'\n'.format(self.x - 1)
+        self.sequence_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=True)
+            
+            self.sequence_str += 'file \'' + self.name + '_{}.png\'\n'.format(self.x)
+            self.sequence_str += 'duration {}\n'.format(1/30)
+        self.x += 1
+    
+    def save_video(self,speed=1,multialpha=False,prerendered=False,clean=True):
+        video_fn = self.name + '.mov'
+        update = status_message("Rendering video...", "Saved video " + video_fn)
+        if not prerendered:
+            self.sequence_str += 'file \'' + self.name + '_{}.png\'\n'.format(self.x-1)#repeat last frame otherwise not seen for some reason
+            self.sequence_str += 'duration {}\n'.format(1/30)
+            with open(self.name + '/' + self.name + '.txt','w+') as f:
+                lines = self.sequence_str.split('\n')
+                for line in lines:
+                    if speed != 1:
+                        if 'duration' in line:
+                            line = 'duration {}'.format(float(line.split(' ')[-1])/speed)
+                    f.write(line + '\n')
+        sequence_fn = self.name + '/' + self.name  + '.txt'
+
+        if multialpha:
+            command = 'ffmpeg -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 -f concat -safe 0 -i {} -y -c:v prores -pix_fmt yuva444p10le -hide_banner -loglevel error {}'.format(sequence_fn,video_fn)
+        subprocess.run(shlex.split(command))
+        if clean:
+            shutil.rmtree(self.name)
+        plt.close()
+        update()
+
+
+#TODO : implementing blitting as in https://matplotlib.org/stable/users/explain/animations/blitting.html
+#has to be an option on the sequence Class, as it can only draw objects on top of the saved background.
+
+#TODO : implement deepcopy of fig so that we can rerun the same code of Sequence without having to reinitialize the fig, because it changes in the sequence code
+#code implemented in the init of sequence, but the axes are regenerated from the copied figure, so if some anims use a specific axis, it does not exist anymore.
+#have to, as initialisation, replace the specific axis with the new one (save old axis in Sequence, find index of specific axis in old axes, get new axis using index)

diplotocus/easings.py

@@ -0,0 +1,17 @@
+#----------------------------------------------
+# EASING CLASSES
+#----------------------------------------------
+class Easing:
+    def __init__(self,func):
+        self.func = func
+
+    def ease(self,x):
+        return self.func(x)
+
+class easeInOutQuart(Easing):
+    def __init__(self):
+        super().__init__(lambda x:8*x**4 if x < 0.5 else 1 - (-2*x + 2)**4 / 2)
+
+class easeLinear(Easing):
+    def __init__(self):
+        super().__init__(lambda x:x)

diplotocus-0.0.1.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: diplotocus
+Version: 0.0.1
+Summary: A python package to generate animations using pyplot.
+Author-email: Tristan Boin <tristan.boin@obspm.fr>
+License-Expression: MIT
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+Diplotocus is a package to render animations of matplotlib plots, in a sequential timeline style.

diplotocus-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+diplotocus/__init__.py,sha256=bODPCi7-gbI4nGoIUKVJ7WclnrncvNhAi7wIfZoaw4I,90
+diplotocus/_version.py,sha256=ugyuFliEqtAwQmH4sTlc16YXKYbFWDmfyk87fErB8-8,21
+diplotocus/animations.py,sha256=EbT8wd8tgY8CgRKLkQj3s0xfeCbfWcW4pxYDoZR9CTc,20137
+diplotocus/core.py,sha256=lUMA3PXlSxCWWKbnYOMJYM9gEjGJdx9M4xcnDnC8FqQ,6909
+diplotocus/easings.py,sha256=XqzW3jSQqczuDUVwVQ8HPOr7z_mkvveWnIp6QOn3Trw,454
+diplotocus-0.0.1.dist-info/licenses/LICENSE,sha256=s8eQhVWRZLr1lA8akzj1JW1RiWTocDzEpUfKzSARYvU,1072
+diplotocus-0.0.1.dist-info/METADATA,sha256=pF1ZpkmFPhZANlGoDBtE984-O5w707MLENQ1amqrYuI,520
+diplotocus-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+diplotocus-0.0.1.dist-info/top_level.txt,sha256=0nwg4ncIvxlo7OPlygJSE2zdUYFkV87w8a2-wRzhIhg,11
+diplotocus-0.0.1.dist-info/RECORD,,

diplotocus-0.0.1.dist-info/WHEEL

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

diplotocus-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Tristan Boin]
+
+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.

diplotocus-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+diplotocus