Add files using upload-large-folder tool

.gitattributes

@@ -1825,3 +1825,4 @@ parrot/lib/python3.10/site-packages/opencv_python.libs/libavutil-a0a0531e.so.57.
 parrot/lib/python3.10/site-packages/scipy/ndimage/_nd_image.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/scipy/interpolate/_ppoly.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/scipy/optimize/_trlib/_trlib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+videollama2/lib/python3.10/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

videollama2/lib/python3.10/site-packages/moviepy/video/compositing/on_color.py

@@ -0,0 +1,27 @@
+from moviepy.video.compositing.CompositeVideoClip import CompositeVideoClip
+from moviepy.video.VideoClip import ColorClip
+
+
+def on_color(clip, size=None, color=(0, 0, 0), pos=None, col_opacity=None):
+    """ 
+    Returns a clip made of the current clip overlaid on a color
+    clip of a possibly bigger size. Can serve to flatten transparent
+    clips (ideal for previewing clips with masks).
+    
+    :param size: size of the final clip. By default it will be the
+       size of the current clip.
+    :param bg_color: the background color of the final clip
+    :param pos: the position of the clip in the final clip.
+    :param col_opacity: should the added zones be transparent ?
+    """
+    
+    if size is None:
+        size = clip.size
+    if pos is None:
+        pos = 'center'
+    colorclip = ColorClip(size, color=color)
+    if col_opacity:
+        colorclip = colorclip.with_mask().set_opacity(col_opacity)
+
+    return CompositeVideoClip([colorclip, clip.set_position(pos)],
+                              transparent=(col_opacity is not None))

videollama2/lib/python3.10/site-packages/moviepy/video/compositing/positioning.py

@@ -0,0 +1,5 @@
+"""
+This module provides classes that make positioning easy
+"""
+
+# class ClipPosition:

videollama2/lib/python3.10/site-packages/moviepy/video/fx/__init__.py

@@ -0,0 +1,4 @@
+"""
+This module contains transformation functions (clip->clip)
+One file for one fx. The file's name is the fx's name
+"""

videollama2/lib/python3.10/site-packages/moviepy/video/fx/accel_decel.py

@@ -0,0 +1,44 @@
+def f_accel_decel(t, old_d, new_d, abruptness=1, soonness=1.0):
+    """
+    abruptness
+      negative abruptness (>-1): speed up down up
+      zero abruptness : no effect
+      positive abruptness: speed down up down
+      
+    soonness
+      for positive abruptness, determines how soon the
+      speedup occurs (0<soonness < inf)
+    """
+    
+    a = 1.0+abruptness
+    def _f(t):
+        f1 = lambda t: (0.5)**(1-a)*(t**a)
+        f2 = lambda t: (1-f1(1-t))
+        return (t<.5)*f1(t) + (t>=.5)*f2(t) 
+    
+    return old_d*_f((t/new_d)**soonness)
+
+
+def accel_decel(clip, new_duration=None, abruptness=1.0, soonness=1.0):
+    """
+
+    new_duration
+      If None, will be that of the current clip.
+
+    abruptness
+      negative abruptness (>-1): speed up down up
+      zero abruptness : no effect
+      positive abruptness: speed down up down
+      
+    soonness
+      for positive abruptness, determines how soon the
+      speedup occurs (0<soonness < inf)
+    """
+    
+    if new_duration is None:
+        new_duration = clip.duration
+    
+    fl = lambda t : f_accel_decel(t, clip.duration, new_duration,
+                                   abruptness, soonness)
+
+    return clip.fl_time(fl).set_duration(new_duration)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/blackwhite.py

@@ -0,0 +1,22 @@
+import numpy as np
+
+
+def blackwhite(clip, RGB = None, preserve_luminosity=True):
+    """ Desaturates the picture, makes it black and white.
+    Parameter RGB allows to set weights for the different color
+    channels.
+    If RBG is 'CRT_phosphor' a special set of values is used.
+    preserve_luminosity maintains the sum of RGB to 1."""
+    if RGB is None:
+        RGB = [1,1,1]
+
+    if RGB == 'CRT_phosphor':
+        RGB = [0.2125, 0.7154, 0.0721]
+
+    R,G,B = 1.0*np.array(RGB)/ (sum(RGB) if preserve_luminosity else 1)
+    
+    def fl(im):
+        im = (R*im[:,:,0] + G*im[:,:,1] + B*im[:,:,2])
+        return np.dstack(3*[im]).astype('uint8')
+
+    return clip.fl_image(fl)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/blink.py

@@ -0,0 +1,15 @@
+import copy
+
+
+def blink(clip, d_on, d_off):
+    """
+    Makes the clip blink. At each blink it will be displayed ``d_on``
+    seconds and disappear ``d_off`` seconds. Will only work in
+    composite clips.
+    """
+    newclip = copy.copy(clip)
+    if newclip.mask is None:
+        newclip = newclip.with_mask()
+    D = d_on + d_off
+    newclip.mask = newclip.mask.fl( lambda gf,t: gf(t)*((t % D) < d_on))
+    return newclip

videollama2/lib/python3.10/site-packages/moviepy/video/fx/colorx.py

@@ -0,0 +1,10 @@
+import numpy as np
+
+
+def colorx(clip, factor):
+    """ multiplies the clip's colors by the given factor, can be used
+        to decrease or increase the clip's brightness (is that the
+        reight word ?)
+    """
+    return clip.fl_image( lambda pic: np.minimum(255,(factor*pic)).
+                                                        astype('uint8'))

videollama2/lib/python3.10/site-packages/moviepy/video/fx/crop.py

@@ -0,0 +1,53 @@
+def crop(clip, x1=None, y1=None, x2=None, y2=None, width=None, height=None, x_center=None, y_center=None):
+    """
+    Returns a new clip in which just a rectangular subregion of the
+    original clip is conserved. x1,y1 indicates the top left corner and
+    x2,y2 is the lower right corner of the croped region.
+    All coordinates are in pixels. Float numbers are accepted.
+    
+    To crop an arbitrary rectangle:
+    
+    >>> crop(clip, x1=50, y1=60, x2=460, y2=275)
+    
+    Only remove the part above y=30:
+    
+    >>> crop(clip, y1=30)
+    
+    Crop a rectangle that starts 10 pixels left and is 200px wide
+    
+    >>> crop(clip, x1=10, width=200)
+    
+    Crop a rectangle centered in x,y=(300,400), width=50, height=150 :
+    
+    >>> crop(clip,  x_center=300 , y_center=400,
+                        width=50, height=150)
+    
+    Any combination of the above should work, like for this rectangle
+    centered in x=300, with explicit y-boundaries:
+    
+    >>> crop(x_center=300, width=400, y1=100, y2=600)
+    
+    """
+
+    if width and x1 is not None:
+        x2 = x1 + width
+    elif width and x2 is not None:
+        x1 = x2 - width
+
+    if height and y1 is not None:
+        y2 = y1 + height
+    elif height and y2 is not None:
+        y1 = y2 - height
+
+    if x_center:
+        x1, x2 = x_center - width / 2, x_center + width / 2
+
+    if y_center:
+        y1, y2 = y_center - height / 2, y_center + height / 2
+
+    x1 = x1 or 0
+    y1 = y1 or 0
+    x2 = x2 or clip.size[0]
+    y2 = y2 or clip.size[1]
+
+    return clip.fl_image(lambda pic: pic[int(y1) : int(y2), int(x1) : int(x2)], apply_to=["mask"])

videollama2/lib/python3.10/site-packages/moviepy/video/fx/even_size.py

@@ -0,0 +1,22 @@
+from moviepy.decorators import apply_to_mask
+
+
+@apply_to_mask
+def even_size(clip):
+    """ 
+    Crops the clip to make dimensions even.
+    """
+    w, h = clip.size
+    w_even = w % 2 == 0
+    h_even = h % 2 == 0
+    if w_even and h_even:
+        return clip
+    
+    if not w_even and not h_even:
+        fl_image = lambda a : a[:-1,:-1,:]
+    elif w_even:
+        fl_image = lambda a : a[:,:-1,:]
+    else:
+        fl_image = lambda a : a[:-1,:,:]
+
+    return clip.fl_image(fl_image)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/fadein.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+
+def fadein(clip, duration, initial_color=None):
+    """
+    Makes the clip progressively appear from some color (black by default),
+    over ``duration`` seconds at the beginning of the clip. Can be used for
+    masks too, where the initial color must be a number between 0 and 1.
+    For cross-fading (progressive appearance or disappearance of a clip
+    over another clip, see ``composition.crossfade``
+    """
+
+    if initial_color is None:
+        initial_color = 0 if clip.ismask else [0,0,0]
+    
+    initial_color = np.array(initial_color)
+    
+    def fl(gf, t):
+        if t>=duration:
+            return gf(t)
+        else:
+            fading = (1.0*t/duration) 
+            return fading*gf(t) + (1-fading)*initial_color
+
+    return clip.fl(fl)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/fadeout.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+from moviepy.decorators import requires_duration
+
+
+@requires_duration
+def fadeout(clip, duration, final_color=None):
+    """
+    Makes the clip progressively fade to some color (black by default),
+    over ``duration`` seconds at the end of the clip. Can be used for
+    masks too, where the final color must be a number between 0 and 1.
+    For cross-fading (progressive appearance or disappearance of a clip
+    over another clip, see ``composition.crossfade``
+    """
+    
+    if final_color is None:
+        final_color = 0 if clip.ismask else [0,0,0]
+    
+    final_color = np.array(final_color)
+
+    def fl(gf, t):
+        if (clip.duration-t)>=duration:
+            return gf(t)
+        else:
+            fading = 1.0 * (clip.duration - t) / duration
+            return fading*gf(t) + (1-fading)*final_color
+
+    return clip.fl(fl)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/gamma_corr.py

@@ -0,0 +1,8 @@
+
+def gamma_corr(clip, gamma):
+    """ Gamma-correction of a video clip """
+    def fl(im):
+        corrected = (255*(1.0*im/255)**gamma)
+        return corrected.astype('uint8')
+    
+    return clip.fl_image(fl)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/headblur.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+#------- CHECKING DEPENDENCIES ----------------------------------------- 
+try:
+    import cv2
+    headblur_possible = True
+    if cv2.__version__ >= '3.0.0':
+       cv2.CV_AA=cv2.LINE_AA
+except:
+    headblur_possible = False
+#-----------------------------------------------------------------------
+
+
+def headblur(clip,fx,fy,r_zone,r_blur=None):
+    """
+    Returns a filter that will blurr a moving part (a head ?) of
+    the frames. The position of the blur at time t is
+    defined by (fx(t), fy(t)), the radius of the blurring
+    by ``r_zone`` and the intensity of the blurring by ``r_blur``.
+    Requires OpenCV for the circling and the blurring.
+    Automatically deals with the case where part of the image goes
+    offscreen.
+    """
+    
+    if r_blur is None: r_blur = 2*r_zone/3
+    
+    def fl(gf,t):
+        
+        im = gf(t)
+        h,w,d = im.shape
+        x,y = int(fx(t)),int(fy(t))
+        x1,x2 = max(0,x-r_zone),min(x+r_zone,w)
+        y1,y2 = max(0,y-r_zone),min(y+r_zone,h)
+        region_size = y2-y1,x2-x1
+        
+        mask = np.zeros(region_size).astype('uint8')
+        cv2.circle(mask, (r_zone,r_zone), r_zone, 255, -1,
+                   lineType=cv2.CV_AA)
+                               
+        mask = np.dstack(3*[(1.0/255)*mask])
+        
+        orig = im[y1:y2, x1:x2]
+        blurred = cv2.blur(orig,(r_blur, r_blur))
+        im[y1:y2, x1:x2] = mask*blurred + (1-mask)*orig
+        return im
+    
+    return clip.fl(fl)
+
+
+
+#------- OVERWRITE IF REQUIREMENTS NOT MET -----------------------------
+if not headblur_possible:
+    doc = headblur.__doc__
+    def headblur(clip,fx,fy,r_zone,r_blur=None):
+        raise IOError("fx painting needs opencv")
+    
+    headblur.__doc__ = doc
+#----------------------------------------------------------------------- 

videollama2/lib/python3.10/site-packages/moviepy/video/fx/invert_colors.py

@@ -0,0 +1,8 @@
+def invert_colors(clip):
+    """ Returns the color-inversed clip.
+
+    The values of all pixels are replaced with (255-v) or (1-v) for masks 
+    Black becomes white, green becomes purple, etc.
+    """
+    maxi = (1.0 if clip.ismask else 255)
+    return clip.fl_image(lambda f : maxi - f)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/loop.py

@@ -0,0 +1,26 @@
+from moviepy.decorators import apply_to_audio, apply_to_mask, requires_duration
+
+
+@requires_duration
+@apply_to_mask
+@apply_to_audio
+def loop(self, n=None, duration=None):
+    """
+    Returns a clip that plays the current clip in an infinite loop.
+    Ideal for clips coming from gifs.
+    
+    Parameters
+    ------------
+    n
+      Number of times the clip should be played. If `None` the
+      the clip will loop indefinitely (i.e. with no set duration).
+
+    duration
+      Total duration of the clip. Can be specified instead of n.
+    """
+    result = self.fl_time(lambda t: t % self.duration)
+    if n:
+        duration = n*self.duration
+    if duration:
+        result = result.set_duration(duration)
+    return result

videollama2/lib/python3.10/site-packages/moviepy/video/fx/lum_contrast.py

@@ -0,0 +1,11 @@
+def lum_contrast(clip, lum = 0, contrast=0, contrast_thr=127):
+    """ luminosity-contrast correction of a clip """
+    
+    def fl_image(im):
+        im = 1.0*im # float conversion
+        corrected = im + lum + contrast*(im-float(contrast_thr))
+        corrected[corrected < 0] = 0
+        corrected[corrected > 255] = 255
+        return corrected.astype('uint8')
+    
+    return clip.fl_image(fl_image)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/make_loopable.py

@@ -0,0 +1,14 @@
+import moviepy.video.compositing.transitions as transfx
+from moviepy.video.compositing.CompositeVideoClip import CompositeVideoClip
+
+
+def make_loopable(clip, cross):
+    """
+    Makes the clip fade in progressively at its own end, this way
+    it can be looped indefinitely. ``cross`` is the duration in seconds
+    of the fade-in.  """  
+    d = clip.duration
+    clip2 = clip.fx(transfx.crossfadein, cross).\
+                 set_start(d - cross)
+    return CompositeVideoClip([ clip, clip2 ]).\
+                 subclip(cross,d)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/margin.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+from moviepy.decorators import apply_to_mask
+from moviepy.video.VideoClip import ImageClip
+
+
+@apply_to_mask
+def margin(clip, mar=None, left=0, right=0, top=0,
+           bottom=0, color=(0, 0, 0), opacity = 1.0):
+    """
+    Draws an external margin all around the frame.
+    
+    :param mar: if not ``None``, then the new clip has a margin of
+        size ``mar`` in pixels on the left, right, top, and bottom.
+        
+    :param left, right, top, bottom: width of the margin in pixel
+        in these directions.
+        
+    :param color: color of the margin.
+    
+    :param mask_margin: value of the mask on the margin. Setting
+        this value to 0 yields transparent margins.
+    
+    """
+
+    if (opacity != 1.0) and (clip.mask is None) and not (clip.ismask):
+        clip = clip.add_mask()
+
+    if mar is not None:
+        left = right = top = bottom = mar
+    
+    def make_bg(w,h):
+        new_w, new_h = w + left + right, h + top + bottom
+        if clip.ismask:
+            shape = (new_h, new_w)
+            bg = ( np.tile(opacity, (new_h, new_w))
+                       .astype(float)
+                       .reshape(shape))
+        else:
+            shape = (new_h, new_w, 3)
+            bg = np.tile(color, (new_h, new_w)).reshape(shape)
+        return bg
+        
+    if isinstance(clip, ImageClip):
+        
+        im =  make_bg(clip.w,clip.h)
+        im[top:top + clip.h, left:left + clip.w] = clip.img
+        return clip.fl_image(lambda pic:im)
+        
+    else:
+        
+        def fl(gf, t):
+            pic = gf(t)
+            h,w = pic.shape[:2]
+            im = make_bg(w,h)
+            im[top:top + h, left:left + w] = pic
+            return im
+        return clip.fl(fl)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/mask_and.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+from ..VideoClip import ImageClip
+
+
+def mask_and(clip, other_clip):
+    """ Returns the logical 'and' (min) between two masks.
+        other_clip can be a mask clip or a picture (np.array).
+        The result has the duration of 'clip' (if it has any)
+    """
+
+    # To ensure that 'or' of two ImageClips will be an ImageClip.
+    if isinstance(other_clip, ImageClip):
+    	other_clip = other_clip.img
+
+    if isinstance(other_clip, np.ndarray):
+    	return clip.fl_image(lambda f : np.minimum(f, other_clip))
+    else:
+    	return clip.fl(lambda gf, t : np.minimum(gf(t),
+    		                                     other_clip.get_frame(t)))

videollama2/lib/python3.10/site-packages/moviepy/video/fx/mask_or.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+from ..VideoClip import ImageClip
+
+
+def mask_or(clip, other_clip):
+    """ Returns the logical 'or' (max) between two masks.
+        other_clip can be a mask clip or a picture (np.array).
+        The result has the duration of 'clip' (if it has any)
+    """
+
+    # To ensure that 'or' of two ImageClips will be an ImageClip.
+    if isinstance(other_clip, ImageClip):
+    	other_clip = other_clip.img
+
+    if isinstance(other_clip, np.ndarray):
+    	return clip.fl_image(lambda f : np.maximum(f, other_clip))
+    else:
+    	return clip.fl(lambda gf, t : np.maximum(gf(t),
+                                                 other_clip.get_frame(t)))

videollama2/lib/python3.10/site-packages/moviepy/video/fx/mirror_x.py

@@ -0,0 +1,4 @@
+
+def mirror_x(clip, apply_to= "mask"):
+    """ flips the clip horizontally (and its mask too, by default) """
+    return clip.fl_image(lambda f: f[:,::-1], apply_to = apply_to)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/mirror_y.py

@@ -0,0 +1,3 @@
+def mirror_y(clip, apply_to= "mask"):
+    """ flips the clip vertically (and its mask too, by default) """
+    return clip.fl_image(lambda f : f[::-1], apply_to = apply_to)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/painting.py

@@ -0,0 +1,43 @@
+#------- CHECKING DEPENDENCIES ----------------------------------------- 
+painting_possible = True
+try:
+    from skimage.filter import sobel
+except:
+    try:
+        from scipy.ndimage.filters import sobel
+    except:
+        painting_possible = False
+#-----------------------------------------------------------------------    
+
+
+
+import numpy as np
+
+
+def to_painting(image,saturation = 1.4,black = 0.006):
+    """ transforms any photo into some kind of painting """
+    edges = sobel(image.mean(axis=2))
+    darkening =  black*(255*np.dstack(3*[edges]))
+    painting = saturation*image-darkening
+    return np.maximum(0,np.minimum(255,painting)).astype('uint8')
+    
+def painting(clip, saturation = 1.4,black = 0.006):
+    """
+    Transforms any photo into some kind of painting. Saturation
+    tells at which point the colors of the result should be
+    flashy. ``black`` gives the anount of black lines wanted.
+    Requires Scikit-image or Scipy installed.
+    """
+    return clip.fl_image(lambda im : to_painting(im,saturation,black))
+        
+
+
+#------- OVERWRITE IF REQUIREMENTS NOT MET -----------------------------
+
+if not painting_possible:
+    doc = painting.__doc__
+    def painting(clip, newsize=None, height=None, width=None):
+        raise IOError("fx painting needs scikit-image or scipy")
+    
+    painting.__doc__ = doc
+#----------------------------------------------------------------------- 

videollama2/lib/python3.10/site-packages/moviepy/video/fx/rotate.py

@@ -0,0 +1,73 @@
+import numpy as np
+
+from moviepy.decorators import apply_to_mask
+
+try:
+    from PIL import Image
+    PIL_FOUND = True
+    def pil_rotater(pic, angle, resample, expand):
+        return np.array( Image.fromarray(pic).rotate(angle, expand=expand,
+                                                     resample=resample))
+except ImportError:
+    PIL_FOUND = False
+
+def rotate(clip, angle, unit='deg', resample="bicubic", expand=True):
+    """
+    Change unit to 'rad' to define angles as radians.
+    If the angle is not one of 90, 180, -90, -180 (degrees) there will be
+    black borders. You can make them transparent with
+
+    >>> newclip = clip.add_mask().rotate(72)
+
+    Parameters
+    ===========
+
+    clip
+      A video clip
+
+    angle
+      Either a value or a function angle(t) representing the angle of rotation
+
+    unit
+      Unit of parameter `angle` (either `deg` for degrees or `rad` for radians)
+
+    resample
+      One of "nearest", "bilinear", or "bicubic".
+
+    expand
+      Only applIf False, the clip will maintain the same True, the clip will be resized so that the whole
+    """
+    
+    resample = {"bilinear": Image.BILINEAR,
+                "nearest": Image.NEAREST,
+                "bicubic": Image.BICUBIC}[resample]
+
+    if not hasattr(angle, '__call__'):
+        # if angle is a constant, convert to a constant function
+        a = +angle
+        angle = lambda t: a
+
+    transpo = [1,0] if clip.ismask else [1,0,2]
+
+    def fl(gf, t):
+
+        a = angle(t)
+        im = gf(t)
+
+        if unit == 'rad':
+            a = 360.0*a/(2*np.pi)
+        
+        if (a==90) and expand:
+            return np.transpose(im, axes=transpo)[::-1]
+        elif (a==-90) and expand:
+            return np.transpose(im, axes=transpo)[:,::-1]
+        elif (a in [180, -180]) and expand:
+            return im[::-1,::-1]
+        elif not PIL_FOUND:
+            raise ValueError('Without "Pillow" installed, only angles 90, -90,'
+                             '180 are supported, please install "Pillow" with'
+                             "pip install pillow")
+        else:
+            return pil_rotater(im, a, resample=resample, expand=expand)
+
+    return clip.fl(fl, apply_to=["mask"])

videollama2/lib/python3.10/site-packages/moviepy/video/fx/scroll.py

@@ -0,0 +1,16 @@
+def scroll(clip, h=None, w=None, x_speed=0, y_speed=0,
+           x_start=0, y_start=0, apply_to="mask"):
+    """ Scrolls horizontally or vertically a clip, e.g. to make end
+        credits """
+    if h is None: h = clip.h
+    if w is None: w = clip.w
+    
+    xmax = clip.w-w-1
+    ymax = clip.h-h-1
+
+    def f(gf,t):
+        x = int(max(0, min(xmax, x_start+ round(x_speed*t))))
+        y = int(max(0, min(ymax, y_start+ round(y_speed*t))))
+        return gf(t)[y:y+h, x:x+w]
+    
+    return clip.fl(f, apply_to = apply_to)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/speedx.py

@@ -0,0 +1,21 @@
+from moviepy.decorators import apply_to_audio, apply_to_mask
+
+
+def speedx(clip, factor = None, final_duration=None):
+    """
+    Returns a clip playing the current clip but at a speed multiplied
+    by ``factor``. Instead of factor one can indicate the desired
+    ``final_duration`` of the clip, and the factor will be automatically
+    computed.
+    The same effect is applied to the clip's audio and mask if any.
+    """
+    
+    if final_duration:
+        factor = 1.0* clip.duration / final_duration
+        
+    newclip = clip.fl_time(lambda t: factor * t, apply_to=['mask', 'audio'])
+    
+    if clip.duration is not None:
+        newclip = newclip.set_duration(1.0 * clip.duration / factor)
+    
+    return newclip

videollama2/lib/python3.10/site-packages/moviepy/video/fx/supersample.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+def supersample(clip, d, nframes):
+    """ Replaces each frame at time t by the mean of `nframes` equally spaced frames
+    taken in the interval [t-d, t+d]. This results in motion blur."""
+    
+    def fl(gf, t):
+        tt = np.linspace(t-d, t+d, nframes)
+        avg = np.mean(1.0*np.array([gf(t_) for t_ in tt], dtype='uint16'), axis=0)
+        return avg.astype("uint8")
+
+    return clip.fl(fl)

videollama2/lib/python3.10/site-packages/moviepy/video/fx/time_symmetrize.py

@@ -0,0 +1,17 @@
+from moviepy.decorators import apply_to_audio, apply_to_mask, requires_duration
+from moviepy.video.compositing.concatenate import concatenate_videoclips
+
+from .time_mirror import time_mirror
+
+
+@requires_duration
+@apply_to_mask
+def time_symmetrize(clip):
+    """
+    Returns a clip that plays the current clip once forwards and
+    then once backwards. This is very practival to make video that
+    loop well, e.g. to create animated GIFs.
+    This effect is automatically applied to the clip's mask and audio
+    if they exist.
+    """
+    return concatenate_videoclips([clip, clip.fx( time_mirror )])

videollama2/lib/python3.10/site-packages/moviepy/video/io/VideoFileClip.py

@@ -0,0 +1,134 @@
+import os
+
+from moviepy.audio.io.AudioFileClip import AudioFileClip
+from moviepy.Clip import Clip
+from moviepy.video.io.ffmpeg_reader import FFMPEG_VideoReader
+from moviepy.video.VideoClip import VideoClip
+
+
+class VideoFileClip(VideoClip):
+
+    """
+
+    A video clip originating from a movie file. For instance: ::
+
+        >>> clip = VideoFileClip("myHolidays.mp4")
+        >>> clip.close()
+        >>> with VideoFileClip("myMaskVideo.avi") as clip2:
+        >>>    pass  # Implicit close called by context manager.
+
+
+    Parameters
+    ------------
+
+    filename:
+      The name of the video file. It can have any extension supported
+      by ffmpeg: .ogv, .mp4, .mpeg, .avi, .mov etc.
+
+    has_mask:
+      Set this to 'True' if there is a mask included in the videofile.
+      Video files rarely contain masks, but some video codecs enable
+      that. For istance if you have a MoviePy VideoClip with a mask you
+      can save it to a videofile with a mask. (see also
+      ``VideoClip.write_videofile`` for more details).
+
+    audio:
+      Set to `False` if the clip doesn't have any audio or if you do not
+      wish to read the audio.
+
+    target_resolution:
+      Set to (desired_height, desired_width) to have ffmpeg resize the frames
+      before returning them. This is much faster than streaming in high-res
+      and then resizing. If either dimension is None, the frames are resized
+      by keeping the existing aspect ratio.
+
+    resize_algorithm:
+      The algorithm used for resizing. Default: "bicubic", other popular
+      options include "bilinear" and "fast_bilinear". For more information, see
+      https://ffmpeg.org/ffmpeg-scaler.html
+
+    fps_source:
+      The fps value to collect from the metadata. Set by default to 'tbr', but
+      can be set to 'fps', which may be helpful if importing slow-motion videos
+      that get messed up otherwise.
+
+
+    Attributes
+    -----------
+
+    filename:
+      Name of the original video file.
+
+    fps:
+      Frames per second in the original file.
+    
+    
+    Read docs for Clip() and VideoClip() for other, more generic, attributes.
+    
+    Lifetime
+    --------
+    
+    Note that this creates subprocesses and locks files. If you construct one of these instances, you must call
+    close() afterwards, or the subresources will not be cleaned up until the process ends.
+    
+    If copies are made, and close() is called on one, it may cause methods on the other copies to fail.  
+
+    """
+
+    def __init__(self, filename, has_mask=False,
+                 audio=True, audio_buffersize=200000,
+                 target_resolution=None, resize_algorithm='bicubic',
+                 audio_fps=44100, audio_nbytes=2, verbose=False,
+                 fps_source='tbr'):
+
+        VideoClip.__init__(self)
+
+        # Make a reader
+        pix_fmt = "rgba" if has_mask else "rgb24"
+        self.reader = FFMPEG_VideoReader(filename, pix_fmt=pix_fmt,
+                                         target_resolution=target_resolution,
+                                         resize_algo=resize_algorithm,
+                                         fps_source=fps_source)
+
+        # Make some of the reader's attributes accessible from the clip
+        self.duration = self.reader.duration
+        self.end = self.reader.duration
+
+        self.fps = self.reader.fps
+        self.size = self.reader.size
+        self.rotation = self.reader.rotation
+
+        self.filename = self.reader.filename
+
+        if has_mask:
+
+            self.make_frame = lambda t: self.reader.get_frame(t)[:,:,:3]
+            mask_mf = lambda t: self.reader.get_frame(t)[:,:,3]/255.0
+            self.mask = (VideoClip(ismask=True, make_frame=mask_mf)
+                         .set_duration(self.duration))
+            self.mask.fps = self.fps
+
+        else:
+
+            self.make_frame = lambda t: self.reader.get_frame(t)
+
+        # Make a reader for the audio, if any.
+        if audio and self.reader.infos['audio_found']:
+
+            self.audio = AudioFileClip(filename,
+                                       buffersize=audio_buffersize,
+                                       fps=audio_fps,
+                                       nbytes=audio_nbytes)
+
+    def close(self):
+        """ Close the internal reader. """
+        if self.reader:
+            self.reader.close()
+            self.reader = None
+
+        try:
+            if self.audio:
+                self.audio.close()
+                self.audio = None
+        except AttributeError:
+            pass

videollama2/lib/python3.10/site-packages/moviepy/video/io/bindings.py

@@ -0,0 +1,32 @@
+"""
+This module implements all the functions to communicate with other Python
+modules (PIL, matplotlib, mayavi, etc.)
+"""
+
+import numpy as np
+
+
+def PIL_to_npimage(im):
+    """ Transforms a PIL/Pillow image into a numpy RGB(A) image.
+        Actually all this do is returning numpy.array(im)."""
+    return np.array(im)
+    #w,h = im.size
+    #d = (4 if im.mode=="RGBA" else 3)
+    #return +np.frombuffer(im.tobytes(), dtype='uint8').reshape((h,w,d))
+
+
+def mplfig_to_npimage(fig):
+    """ Converts a matplotlib figure to a RGB frame after updating the canvas"""
+    #  only the Agg backend now supports the tostring_rgb function
+    from matplotlib.backends.backend_agg import FigureCanvasAgg
+    canvas = FigureCanvasAgg(fig)
+    canvas.draw() # update/draw the elements
+
+    # get the width and the height to resize the matrix
+    l,b,w,h = canvas.figure.bbox.bounds
+    w, h = int(w), int(h)
+
+    #  exports the canvas to a string buffer and then to a numpy nd.array
+    buf = canvas.tostring_rgb()
+    image= np.frombuffer(buf, dtype=np.uint8)
+    return image.reshape(h,w,3)

videollama2/lib/python3.10/site-packages/moviepy/video/io/ffmpeg_reader.py

@@ -0,0 +1,393 @@
+"""
+This module implements all the functions to read a video or a picture
+using ffmpeg. It is quite ugly, as there are many pitfalls to avoid
+"""
+
+from __future__ import division
+
+import logging
+import os
+import re
+import subprocess as sp
+import warnings
+
+import numpy as np
+
+from moviepy.compat import DEVNULL, PY3
+from moviepy.config import get_setting  # ffmpeg, ffmpeg.exe, etc...
+from moviepy.tools import cvsecs
+
+logging.captureWarnings(True)
+
+
+
+
+
+class FFMPEG_VideoReader:
+
+    def __init__(self, filename, print_infos=False, bufsize = None,
+                 pix_fmt="rgb24", check_duration=True,
+                 target_resolution=None, resize_algo='bicubic',
+                 fps_source='tbr'):
+
+        self.filename = filename
+        self.proc = None
+        infos = ffmpeg_parse_infos(filename, print_infos, check_duration,
+                                   fps_source)
+        self.fps = infos['video_fps']
+        self.size = infos['video_size']
+        self.rotation = infos['video_rotation']
+
+        if target_resolution:
+            # revert the order, as ffmpeg used (width, height)
+            target_resolution = target_resolution[1], target_resolution[0]
+
+            if None in target_resolution:
+                ratio = 1
+                for idx, target in enumerate(target_resolution):
+                    if target:
+                        ratio = target / self.size[idx]
+                self.size = (int(self.size[0] * ratio), int(self.size[1] * ratio))
+            else:
+                self.size = target_resolution
+        self.resize_algo = resize_algo
+
+        self.duration = infos['video_duration']
+        self.ffmpeg_duration = infos['duration']
+        self.nframes = infos['video_nframes']
+
+        self.infos = infos
+
+        self.pix_fmt = pix_fmt
+        self.depth = 4 if pix_fmt == 'rgba' else 3
+
+        if bufsize is None:
+            w, h = self.size
+            bufsize = self.depth * w * h + 100
+
+        self.bufsize= bufsize
+        self.initialize()
+
+
+        self.pos = 1
+        self.lastread = self.read_frame()
+
+
+    def initialize(self, starttime=0):
+        """Opens the file, creates the pipe. """
+
+        self.close() # if any
+
+        if starttime != 0 :
+            offset = min(1, starttime)
+            i_arg = ['-ss', "%.06f" % (starttime - offset),
+                     '-i', self.filename,
+                     '-ss', "%.06f" % offset]
+        else:
+            i_arg = [ '-i', self.filename]
+
+        cmd = ([get_setting("FFMPEG_BINARY")] + i_arg +
+               ['-loglevel', 'error',
+                '-f', 'image2pipe',
+                '-vf', 'scale=%d:%d' % tuple(self.size),
+                '-sws_flags', self.resize_algo,
+                "-pix_fmt", self.pix_fmt,
+                '-vcodec', 'rawvideo', '-'])
+        popen_params = {"bufsize": self.bufsize,
+                        "stdout": sp.PIPE,
+                        "stderr": sp.PIPE,
+                        "stdin": DEVNULL}
+
+        if os.name == "nt":
+            popen_params["creationflags"] = 0x08000000
+
+        self.proc = sp.Popen(cmd, **popen_params)
+
+
+    def skip_frames(self, n=1):
+        """Reads and throws away n frames """
+        w, h = self.size
+        for i in range(n):
+            self.proc.stdout.read(self.depth*w*h)
+            #self.proc.stdout.flush()
+        self.pos += n
+
+
+    def read_frame(self):
+        w, h = self.size
+        nbytes= self.depth*w*h
+
+        s = self.proc.stdout.read(nbytes)
+        if len(s) != nbytes:
+
+            warnings.warn("Warning: in file %s, "%(self.filename)+
+                   "%d bytes wanted but %d bytes read,"%(nbytes, len(s))+
+                   "at frame %d/%d, at time %.02f/%.02f sec. "%(
+                    self.pos,self.nframes,
+                    1.0*self.pos/self.fps,
+                    self.duration)+
+                   "Using the last valid frame instead.",
+                   UserWarning)
+
+            if not hasattr(self, 'lastread'):
+                raise IOError(("MoviePy error: failed to read the first frame of "
+                               "video file %s. That might mean that the file is "
+                               "corrupted. That may also mean that you are using "
+                               "a deprecated version of FFMPEG. On Ubuntu/Debian "
+                               "for instance the version in the repos is deprecated. "
+                               "Please update to a recent version from the website.")%(
+                                self.filename))
+
+            result = self.lastread
+
+        else:
+            if hasattr(np, 'frombuffer'):
+                result = np.frombuffer(s, dtype='uint8')
+            else:
+                result = np.fromstring(s, dtype='uint8')
+            result.shape =(h, w, len(s)//(w*h)) # reshape((h, w, len(s)//(w*h)))
+            self.lastread = result
+
+        return result
+
+    def get_frame(self, t):
+        """ Read a file video frame at time t.
+
+        Note for coders: getting an arbitrary frame in the video with
+        ffmpeg can be painfully slow if some decoding has to be done.
+        This function tries to avoid fetching arbitrary frames
+        whenever possible, by moving between adjacent frames.
+        """
+
+        # these definitely need to be rechecked sometime. Seems to work.
+
+        # I use that horrible '+0.00001' hack because sometimes due to numerical
+        # imprecisions a 3.0 can become a 2.99999999... which makes the int()
+        # go to the previous integer. This makes the fetching more robust in the
+        # case where you get the nth frame by writing get_frame(n/fps).
+
+        pos = int(self.fps*t + 0.00001)+1
+
+        # Initialize proc if it is not open
+        if not self.proc:
+            self.initialize(t)
+            self.pos = pos
+            self.lastread = self.read_frame()
+
+        if pos == self.pos:
+            return self.lastread
+        elif (pos < self.pos) or (pos > self.pos + 100):
+            self.initialize(t)
+            self.pos = pos
+        else:
+            self.skip_frames(pos-self.pos-1)
+        result = self.read_frame()
+        self.pos = pos
+        return result
+
+    def close(self):
+        if self.proc:
+            self.proc.terminate()
+            self.proc.stdout.close()
+            self.proc.stderr.close()
+            self.proc.wait()
+            self.proc = None
+        if hasattr(self, 'lastread'):
+            del self.lastread
+
+    def __del__(self):
+        self.close()
+
+
+def ffmpeg_read_image(filename, with_mask=True):
+    """ Read an image file (PNG, BMP, JPEG...).
+
+    Wraps FFMPEG_Videoreader to read just one image.
+    Returns an ImageClip.
+
+    This function is not meant to be used directly in MoviePy,
+    use ImageClip instead to make clips out of image files.
+
+    Parameters
+    -----------
+
+    filename
+      Name of the image file. Can be of any format supported by ffmpeg.
+
+    with_mask
+      If the image has a transparency layer, ``with_mask=true`` will save
+      this layer as the mask of the returned ImageClip
+
+    """
+    pix_fmt = 'rgba' if with_mask else "rgb24" 
+    reader = FFMPEG_VideoReader(filename, pix_fmt=pix_fmt, check_duration=False)
+    im = reader.lastread
+    del reader
+    return im
+
+
+def ffmpeg_parse_infos(filename, print_infos=False, check_duration=True,
+                       fps_source='tbr'):
+    """Get file infos using ffmpeg.
+
+    Returns a dictionnary with the fields:
+    "video_found", "video_fps", "duration", "video_nframes",
+    "video_duration", "audio_found", "audio_fps"
+
+    "video_duration" is slightly smaller than "duration" to avoid
+    fetching the uncomplete frames at the end, which raises an error.
+
+    """
+
+
+    # open the file in a pipe, provoke an error, read output
+    is_GIF = filename.endswith('.gif')
+    cmd = [get_setting("FFMPEG_BINARY"), "-i", filename]
+    if is_GIF:
+        cmd += ["-f", "null", "/dev/null"]
+
+    popen_params = {"bufsize": 10**5,
+                    "stdout": sp.PIPE,
+                    "stderr": sp.PIPE,
+                    "stdin": DEVNULL}
+
+    if os.name == "nt":
+        popen_params["creationflags"] = 0x08000000
+
+    proc = sp.Popen(cmd, **popen_params)
+    (output, error) = proc.communicate()
+    infos = error.decode('utf8')
+
+    del proc
+
+    if print_infos:
+        # print the whole info text returned by FFMPEG
+        print(infos)
+
+
+    lines = infos.splitlines()
+    if "No such file or directory" in lines[-1]:
+        raise IOError(("MoviePy error: the file %s could not be found!\n"
+                      "Please check that you entered the correct "
+                      "path.")%filename)
+
+    result = dict()
+
+
+    # get duration (in seconds)
+    result['duration'] = None
+
+    if check_duration:
+        try:
+            keyword = ('frame=' if is_GIF else 'Duration: ')
+            # for large GIFS the "full" duration is presented as the last element in the list.
+            index = -1 if is_GIF else 0
+            line = [l for l in lines if keyword in l][index]
+            match = re.findall("([0-9][0-9]:[0-9][0-9]:[0-9][0-9].[0-9][0-9])", line)[0]
+            result['duration'] = cvsecs(match)
+        except:
+            raise IOError(("MoviePy error: failed to read the duration of file %s.\n"
+                           "Here are the file infos returned by ffmpeg:\n\n%s")%(
+                              filename, infos))
+
+    # get the output line that speaks about video
+    lines_video = [l for l in lines if ' Video: ' in l and re.search('\d+x\d+', l)]
+
+    result['video_found'] = ( lines_video != [] )
+
+    if result['video_found']:
+        try:
+            line = lines_video[0]
+
+            # get the size, of the form 460x320 (w x h)
+            match = re.search(" [0-9]*x[0-9]*(,| )", line)
+            s = list(map(int, line[match.start():match.end()-1].split('x')))
+            result['video_size'] = s
+        except:
+            raise IOError(("MoviePy error: failed to read video dimensions in file %s.\n"
+                           "Here are the file infos returned by ffmpeg:\n\n%s")%(
+                              filename, infos))
+
+        # Get the frame rate. Sometimes it's 'tbr', sometimes 'fps', sometimes
+        # tbc, and sometimes tbc/2...
+        # Current policy: Trust tbr first, then fps unless fps_source is
+        # specified as 'fps' in which case try fps then tbr
+
+        # If result is near from x*1000/1001 where x is 23,24,25,50,
+        # replace by x*1000/1001 (very common case for the fps).
+
+        def get_tbr():
+            match = re.search("( [0-9]*.| )[0-9]* tbr", line)
+
+            # Sometimes comes as e.g. 12k. We need to replace that with 12000.
+            s_tbr = line[match.start():match.end()].split(' ')[1]
+            if "k" in s_tbr:
+                tbr = float(s_tbr.replace("k", "")) * 1000
+            else:
+                tbr = float(s_tbr)
+            return tbr
+
+        def get_fps():
+            match = re.search("( [0-9]*.| )[0-9]* fps", line)
+            fps = float(line[match.start():match.end()].split(' ')[1])
+            return fps
+
+        if fps_source == 'tbr':
+            try:
+                result['video_fps'] = get_tbr()
+            except:
+                result['video_fps'] = get_fps()
+
+        elif fps_source == 'fps':
+            try:
+                result['video_fps'] = get_fps()
+            except:
+                result['video_fps'] = get_tbr()
+
+        # It is known that a fps of 24 is often written as 24000/1001
+        # but then ffmpeg nicely rounds it to 23.98, which we hate.
+        coef = 1000.0/1001.0
+        fps = result['video_fps']
+        for x in [23,24,25,30,50]:
+            if (fps!=x) and abs(fps - x*coef) < .01:
+                result['video_fps'] = x*coef
+
+        if check_duration:
+            result['video_nframes'] = int(result['duration']*result['video_fps'])+1
+            result['video_duration'] = result['duration']
+        else:
+            result['video_nframes'] = 1
+            result['video_duration'] = None
+        # We could have also recomputed the duration from the number
+        # of frames, as follows:
+        # >>> result['video_duration'] = result['video_nframes'] / result['video_fps']
+
+        # get the video rotation info.
+        try:
+            rotation_lines = [l for l in lines if 'rotate          :' in l and re.search('\d+$', l)]
+            if len(rotation_lines):
+                rotation_line = rotation_lines[0]
+                match = re.search('\d+$', rotation_line)
+                result['video_rotation'] = int(rotation_line[match.start() : match.end()])
+            else:
+                result['video_rotation'] = 0
+        except:
+            raise IOError(("MoviePy error: failed to read video rotation in file %s.\n"
+                           "Here are the file infos returned by ffmpeg:\n\n%s")%(
+                              filename, infos))
+
+
+    lines_audio = [l for l in lines if ' Audio: ' in l]
+
+    result['audio_found'] = lines_audio != []
+
+    if result['audio_found']:
+        line = lines_audio[0]
+        try:
+            match = re.search(" [0-9]* Hz", line)
+            hz_string = line[match.start()+1:match.end()-3]  # Removes the 'hz' from the end
+            result['audio_fps'] = int(hz_string)
+        except:
+            result['audio_fps'] = 'unknown'
+
+    return result