W|hSrSSKrSSKrSSKrSSKJr SSKJrJ r J r J r SSK r SSKrSSKJr SSKJr SSKJrJrJr SSKJr \(aSS KJr SS KJr SS KJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r' SS K(J)r)J*r*J+r+ SS K,J-r- SSK.J/r/ SSK0J1r1 SSK2J3r3 SSK4J5r5 "SS\5r6"SS\65r7"SS\65r8"SS\65r9"SS\95r:"SS\95r;"SS\65rjr=S?r>S@r?SAr@U=rA$)S VideoClip-aBase class for video clips. See ``VideoFileClip``, ``ImageClip`` etc. for more user-friendly classes. Parameters ---------- is_mask `True` if the clip is going to be used as a mask. duration Duration of the clip in seconds. If None we got a clip of infinite duration has_constant_size Define if clip size is constant or if it may vary with time. Default to True Attributes ---------- size The size of the clip, (width,height), in pixels. w, h The width and height of the clip, in pixels. is_mask Boolean set to `True` if the clip is a mask. frame_function A function ``t-> frame at time t`` where ``frame`` is a w*h*3 RGB array. mask (default None) VideoClip mask attached to this clip. If mask is ``None``, The video clip is fully opaque. audio (default None) An AudioClip instance containing the audio of the video clip. pos A function ``t->(x,y)`` where ``x,y`` is the position of the clip when it is composed with other clips. See ``VideoClip.set_pos`` for more details relative_pos See variable ``pos``. layer Indicates which clip is rendered on top when two clips overlap in a CompositeVideoClip. The highest number is rendered on top. Default is 0. c>[TU]5 SUlSUlSUlSUlSUlU(a/XlURS5RSSSSS2Ul X l X@l Ub X0l X0lgg)Ncg)Nrrts Q/home/james-whalen/.local/lib/python3.13/site-packages/moviepy/video/VideoClip.py$VideoClip.__init__..osVFr)super__init__maskaudiopos relative_pos layer_indexframe_function get_frameshapesizeis_maskhas_constant_sizedurationend)selfr9r=r?r> __class__s r,r3VideoClip.__init__is   #! "0 q)//3DbD9DI !2  $MH r/c URS$)zReturns the width of the video.rr<rAs r,w VideoClip.w{yy|r/c URS$)z Returns the height of the video.rErFs r,h VideoClip.hrIr/cFUR[UR5- $)z&Returns the aspect ratio of the video.)rGfloatrLrFs r, aspect_ratioVideoClip.aspect_ratiosvvdff %%r/cF[URUR-5$)z*Returns the number of frames of the video.)intr?fpsrFs r,n_framesVideoClip.n_framess 4==488+,,r/cURnURU5nURH6n[X5nUS;a[R "U5n[ X#U5 M8 U$)aMixed copy of the clip. Returns a shallow copy of the clip whose mask and audio will be shallow copies of the clip's mask and audio if they exist. This method is intensively used to produce new clips every time there is an outplace transformation of the clip (clip.resize, clip.subclipped, etc.) Acts like a deepcopy except for the fact that readers and other possible unpickleables objects are not copied. )r4r5)rB__new____dict__getattr_copycopysetattr)rAclsnew_clipattrvalues r,__copy__VideoClip.__copy__s[nn;;s#MMDD'E(( 5) HE * " r/r+cURU5nU(aRURbESURRU5-n[R"XE/5R S5nOUR S5n[ X5 g)a'Save a clip's frame to an image file. Saves the frame of clip corresponding to time ``t`` in ``filename``. ``t`` can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. Parameters ---------- filename : str Name of the file in which the frame will be stored. t : float or tuple or str, optional Moment of the frame to be saved. As default, the first frame will be saved. with_mask : bool, optional If is ``True`` the mask is saved in the alpha layer of the picture (only works with PNGs). Nuint8)r:r4npdstackastyper )rAfilenamer+ with_maskimr4s r, save_frameVideoClip.save_framesh.^^A  .,,Q//DB:&--g6B7#Br/)rjtemp_audiofiletemp_audiofile_pathc[RR[RRU55unnUSSR 5n[ R "U5nUc[USSnU c US;aSn OSn OU S :XaS n OU S :XaS n [U[5(aUOSnUSL=(a US L=(a URSLnU(a U (aU nOIU(aB[U 5n[RRU U[R -SU--5nU"SU-S9 U(a"URR#UUUU U U UUS9 Sn [%UUUUUUUUU UUUUS9 U(aAU(a:[RR'U5(a[R("U5 U"SU-S9 g![a [S5ef=f)aGWrite the clip to a videofile. Parameters ---------- filename Name of the video file to write in, as a string or a path-like object. The extension must correspond to the "codec" used (see below), or simply be '.avi' (which will work with any codec). fps Number of frames per second in the resulting video file. If None is provided, and the clip has an fps attribute, this fps will be used. codec Codec to use for image encoding. Can be any codec supported by ffmpeg. If the filename is has extension '.mp4', '.ogv', '.webm', the codec will be set accordingly, but you can still set it if you don't like the default. For other extensions, the output filename must be set accordingly. Some examples of codecs are: - ``'libx264'`` (default codec for file extension ``.mp4``) makes well-compressed videos (quality tunable using 'bitrate'). - ``'mpeg4'`` (other codec for extension ``.mp4``) can be an alternative to ``'libx264'``, and produces higher quality videos by default. - ``'rawvideo'`` (use file extension ``.avi``) will produce a video of perfect quality, of possibly very huge size. - ``png`` (use file extension ``.avi``) will produce a video of perfect quality, of smaller size than with ``rawvideo``. - ``'libvorbis'`` (use file extension ``.ogv``) is a nice video format, which is completely free/ open source. However not everyone has the codecs installed by default on their machine. - ``'libvpx'`` (use file extension ``.webm``) is tiny a video format well indicated for web videos (with HTML5). Open source. audio Either ``True``, ``False``, or a file name. If ``True`` and the clip has an audio clip attached, this audio clip will be incorporated as a soundtrack in the movie. If ``audio`` is the name of an audio file, this audio file will be incorporated as a soundtrack in the movie. audio_fps frame rate to use when generating the sound. temp_audiofile the name of the temporary audiofile, as a string or path-like object, to be created and then used to write the complete video, if any. temp_audiofile_path the location that the temporary audiofile is placed, as a string or path-like object. Defaults to the current working directory. audio_codec Which audio codec should be used. Examples are 'libmp3lame' for '.mp3', 'libvorbis' for 'ogg', 'libfdk_aac':'m4a', 'pcm_s16le' for 16-bit wav and 'pcm_s32le' for 32-bit wav. Default is 'libmp3lame', unless the video extension is 'ogv' or 'webm', at which case the default is 'libvorbis'. audio_bitrate Audio bitrate, given as a string like '50k', '500k', '3000k'. Will determine the size/quality of audio in the output file. Note that it mainly an indicative goal, the bitrate won't necessarily be the this in the final file. preset Sets the time that FFMPEG will spend optimizing the compression. Choices are: ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow, placebo. Note that this does not impact the quality of the video, only the size of the video file. So choose ultrafast when you are in a hurry and file size does not matter. threads Number of threads to use for ffmpeg. Can speed up the writing of the video on multicore computers. ffmpeg_params Any additional ffmpeg parameters you would like to pass, as a list of terms, like ['-option1', 'value1', '-option2', 'value2']. write_logfile If true, will write log files for the audio and the video. These will be files ending with '.log' with the name of the output file in them. logger Either ``"bar"`` for progress bar or ``None`` or any Proglog logger. pixel_format Pixel format for the output video file. Examples -------- .. code:: python from moviepy import VideoFileClip clip = VideoFileClip("myvideo.mp4").subclipped(100,120) clip.write_videofile("my_new_video.mp4") clip.close() rKNcodecrzoMoviePy couldn't find the codec associated with the filename. Provide the 'codec' parameter in write_videofile.)ogvwebm libvorbis libmp3lameraw16 pcm_s16leraw32 pcm_s32leTz wvf_snd.%szMoviePy - Building video %s.)message)bitrate write_logfileloggerr\) r|presetr} audiofile audio_codecthreads ffmpeg_paramsr~ pixel_formatzMoviePy - video ready %s)ospathsplitextbasenamelowerproglogdefault_bar_loggerrKeyError ValueError isinstancestrr5rjoinr_TEMP_FILES_PREFIXwrite_audiofiler existsremove)rArjrTrrr|r5 audio_fpsr audio_nbytesr audio_bitrate audio_bufsizerorp remove_tempr}rrr~rnameextr make_audio audio_exts r,write_videofileVideoClip.write_videofilesHGG$$RWW%5%5h%?@ c!"gmmo++F3 = ',W5a8  o%) * G #%K G #%K's33E $  PUd] P49O  .&I &{3I #t... 1III 5@A  JJ & &%+ ' !K    '#'% :ww~~i(( )$1H<=K  4 s -G G"c[R"U5n[R"SURSU- 5n/nUR [ [U55S9H*upxX-n URU 5 URXUS9 M, U$)a Writes the videoclip to a sequence of image files. Parameters ---------- name_format A filename specifying the numerotation format and extension of the pictures. For instance "frame%03d.png" for filenames indexed with 3 digits and PNG format. Also possible: "some_folder/frame%04d.jpeg", etc. fps Number of frames per second to consider when writing the clip. If not specified, the clip's ``fps`` attribute will be used if it has one. with_mask will save the clip's mask (if any) as an alpha canal (PNGs only). logger Either ``"bar"`` for progress bar or ``None`` or any Proglog logger. Returns ------- names_list A list of all the files generated. Notes ----- The resulting image sequence can be read using e.g. the class ``ImageSequenceClip``. r?r*rk) rrrgaranger?iter_barlist enumerateappendrm) rA name_formatrTrkr~timings filenamesir+rs r,write_images_sequenceVideoClip.write_images_sequencesT++F3))At}}cCi8 OOd9W+=&>O?DA?D   T " OODyO 9@ r/rjc[UUUUUS9 g)aWrite the VideoClip to a GIF file. Converts a VideoClip into an animated GIF using imageio Parameters ---------- filename Name of the resulting gif file, as a string or a path-like object. fps Number of frames per second (see note below). If it isn't provided, then the function will look for the clip's ``fps`` attribute (VideoFileClip, for instance, have one). loop : int, optional Repeat the clip using ``loop`` iterations in the resulting GIF. progress_bar If True, displays a progress bar Notes ----- The gif will be playing the clip in real time (you can only change the frame rate). If you want the gif to be played slower than the clip you will use .. code:: python # slow down clip 50% and make it a gif myClip.multiply_speed(0.5).to_gif('myClip.gif') )rTloopr~Nr!)rArjrTrr~s r, write_gifVideoClip.write_gifs`     r/cUR5nURU5n[R"UR S55nUR 5 g)aSplashes the frame of clip corresponding to time ``t``. Parameters ---------- t : float or tuple or str, optional Time in seconds of the frame to display. with_mask : bool, optional ``False`` if the clip has a mask but you want to see the clip without the mask. Examples -------- .. code:: python from moviepy import * clip = VideoFileClip("media/chaplin.mp4") clip.show(t=4) rfN)r\r:r fromarrayrishow)rAr+rkclipframepil_imgs r,rVideoClip.shows?2yy{q!//%,,w"78 r/c,U=(a URSLnSnSnU(ah[R"5n[R"5n[R"URRUUUUU4S9nUR 5 [ XXgS9 g)auDisplays the clip in a window, at the given frames per second. It will avoid that the clip be played faster than normal, but it cannot avoid the clip to be played slower than normal if the computations are complex. In this case, try reducing the ``fps``. Parameters ---------- fps : int, optional Number of frames per seconds in the displayed video. Default to ``15``. audio : bool, optional ``True`` (default) if you want the clip's audio be played during the preview. audio_fps : int, optional The frames per second to use when generating the audio sound. audio_buffersize : int, optional The sized of the buffer used generating the audio sound. audio_nbytes : int, optional The number of bytes used generating the audio sound. Examples -------- .. code:: python from moviepy import * clip = VideoFileClip("media/chaplin.mp4") clip.preview(fps=10, audio=False) N)targetargs)rrT audio_flag video_flag)r5 threadingEventThread audiopreviewstartr ) rArTr5raudio_buffersizerrr audiothreads r,previewVideoClip.preview;sN24::T1   #*J"*J#**zz..$   K     : r/effectsrc *US:XaSOURSU5nURX#5R"U40UD6nUcSOURUS9nXVU4Vs/sH ocMUPM n nSSKJn U "U 5R UR 5$s snf)aApply a transformation to a part of the clip. Returns a new clip in which the function ``fun`` (clip->clip) has been applied to the subclip between times `start_time` and `end_time` (in seconds). Examples -------- .. code:: python # The scene between times t=3s and t=6s in ``clip`` will be # be played twice slower in ``new_clip`` new_clip = clip.with_sub_effect(MultiplySpeed(0.5), 3, 6) rN) start_timeconcatenate_videoclips) subclipped with_effects,moviepy.video.compositing.CompositeVideoClipr with_startr) rArrend_timekwargsleftcenterrightrclipsrs r,with_effects_on_subclip!VideoClip.with_effects_on_subclips&#atdooa.L6CCGVvV!)80T#'"7L"7$"7L X%e,77 CC Ms B!BcF^U=(d /nURU4SjU5$)zsModifies the images of a clip by replacing the frame `get_frame(t)` by another frame, `image_func(get_frame(t))`. c >T"U"U55$Nr))r:r+ image_funcs r,r-+VideoClip.image_transform..s:il3Kr/) transform)rArapply_tos ` r,image_transformVideoClip.image_transforms >r~~KXVVr/c\URnUSUS- nUSUS- nUnUS:a USUSnO,US:a&/SQ/US-/U-n[R"X45nUS:aUSS2SUS24nU$US:a0/SQ/U-/URS-n[R"Xg45nU$)a7Fills an array to match the specified shape. If the `pre_array` is smaller than the desired shape, the missing rows or columns are added with ones to the bottom or right, respectively, until the shape matches. If the `pre_array` is larger than the desired shape, the excess rows or columns are cropped from the bottom or right, respectively, until the shape matches. The resulting array with the filled shape is returned. Parameters ---------- pre_array (numpy.ndarray) The original array to be filled. shape (tuple) The desired shape of the resulting array. rrKN)rKrKrK)r;rgvstackhstack)rA pre_arrayr; pre_shapedxdy post_arrayx_1s r, fill_arrayVideoClip.fill_arrays&OO 1X ! $ 1X ! $ 6":U1X.J !V;1-.3CI#34J 6#AzqzM2J!V;#$z'7'7'::CJ#45Jr/ backgroundreturncX R- nURU5RS5n[R"U5nUR bUR RU5S-RS5n[R"U5R S5nURUR:wahURupURupX:dX:aURSSX45nO-[R"SX4S5n U RUS5 U nUR S5nURU5 URU5n [URURXR5n URSS:wa&URSS:waURX]5 U$URSS:waUR S5nURSS:waUR S5n[R"SUR UR"4S 5nURX]5 [R$"X5nU$) aReturns the result of the clip's frame at time `t` on top on the given `picture`, the position of the clip being given by the clip's ``pos`` attribute. Meant for compositing. If the clip/backgrounds have transparency the transparency will be accounted for. The return is a Pillow Image Parameters ---------- backrgound (Image) The background image to apply current clip on top of if the background image is transparent it must be given as a RGBA image t The time of clip to apply on top of clip Return rfreLrr(RGBAr1Arrrr)rr:rir rr4convertr<cropnewpasteputalphar6rr7modewidthheightalpha_composite)rArr+ct clip_frameclip_img clip_mask clip_mask_img mask_width mask_height img_width img_heightnew_maskr6canvasresults r, compose_onVideoClip.compose_ons*^^^B'..w7 ??:. 99 ,,R036>>wGI!OOI6>>sCM!!X]]2*7*<*<' (0 % )[-E$1$6$61i7T$UM %yyy.EqIHNN=&9$,M''/H   m ,hhrlx}}joosDUDUV ==  # (;s(B   X +  ??2 # %#++F3J ==  #''/H 6J$4$4j6G6G#H,W X#&&z: r/background_maskcX R- nURU5RS5nURupVURupxUR U5n [ X4Xe4XR 5n [[U SS55n [[U SU-U55n [[U SS55n [[U SU-U55n [[SU S*55n[U[X- X- 5-5n[[SU S*55n[U[X- UU- 5-5nUX2X24UUU2X24SXU 2X24- --XU 2X24'U$)aReturns the result of the clip's mask at time `t` composited on the given `background_mask`, the position of the clip being given by the clip's ``pos`` attribute. Meant for compositing. (warning: only use this function to blit two masks together, never images) Parameters ---------- background_mask: The underlying mask onto which the clip mask will be composed. t: The time position in the clip at which to extract the mask. rOrrK) rr:rir;r6rr7rSmaxmin)rAr r+rrbg_hbg_wclip_hclip_wr6x_startx_endy_starty_end clip_x_start clip_x_end clip_y_start clip_y_ends r, compose_maskVideoClip.compose_masks^NN2&--g6 %** "hhrl/$sDUDUVc#a&!n%CA./c#a&!n%CA./ 3q3q6'?+ U_@U(WWX 3q3q6'?+ U_@U(WWX "9H M7= (9 l:-|/FF G  w} <= = 9  w}45 r/c8SSKJn Uc URnUcSnUb<[XURS9R U5nU"X`R U5/5nOU"UR U5/XS9n[U[5(a[US5(dURb[UR[5(aWUR5nURbURR5Ul URUR5$U$)aPlace the clip on a colored background. Returns a clip made of the current clip overlaid on a color clip of a possibly bigger size. Can serve to flatten transparent clips. Parameters ---------- size Size (width, height) in pixels of the final clip. By default it will be the size of the current clip. color Background color of the final clip ([R,G,B]). pos Position of the clip in the final clip. 'center' is the default opacity Parameter in 0..1 indicating the opacity of the colored background. r)CompositeVideoClipr)colorr?)r<bg_color__call__) rrr< ColorClipr? with_opacity with_positionr ImageCliphasattrr4 to_ImageClip with_duration) rAr<rr6opacityr colorclipr new_results r,with_background_colorVideoClip.with_background_color]s0 T <99D ;C  !DMMl7# (4F4Fs4K(LMF'##C()F tY ' 'S*--))# 499i(H(H,,.J{{&"(++":":"< ++FOO< < r/r9cbXlURS5RSSSSS2Ulg)z{Change the clip's ``get_frame``. Returns a copy of the VideoClip instance, with the frame_function attribute set to `mf`. rNr0r1)r9r:r;r<)rAr9s r,with_updated_frame_function%VideoClip.with_updated_frame_functions0-NN1%++BQ/"5 r/cXlg)zAttach an AudioClip to the VideoClip. Returns a copy of the VideoClip instance, with the `audio` attribute set to ``audio``, which must be an AudioClip instance. Nr5)rA audioclips r, with_audioVideoClip.with_audios  r/r4c^US:Xa7TR(a[TRSSS9nOU4Sjn[SUS9nUTlg)a Set the clip's mask. Returns a copy of the VideoClip with the mask attribute set to ``mask``, which must be a greyscale (values in 0-1) VideoClip. Parameters ---------- mask : Union["VideoClip", str], optional The mask to apply to the clip. If set to "auto", a default mask will be generated: - If the clip has a constant size, a solid mask with a value of 1.0 will be created. - Otherwise, a dynamic solid mask will be created based on the frame size. autorTr=cn>[R"TRU5RSS[S9$)Nr0)dtype)rgonesr:r;rOr+rAs r,r9+VideoClip.with_mask..frame_functions*774>>!#4#:#:2A#>eLLr/)r=r9N)r>r!r<r$r4)rAr4r9s` r,rkVideoClip.with_masksB" 6>%% C>M!nM r/cSUlg)zRemove the clip's mask.N)r4rFs r, without_maskVideoClip.without_masks  r/cN^URRU4Sj5Ulg)zSet the opacity/transparency level of the clip. Returns a semi-transparent copy of the clip where the mask is multiplied by ``op`` (any float, normally between 0 and 1). c>TU-$rr))picr(s r,r-(VideoClip.with_opacity..s 'C-r/N)r4r)rAr(s `r,r"VideoClip.with_opacitysII--.GH r/cZ^X l[TS5(aTUlgU4SjUlg)aSet the clip's position in compositions. Sets the position that the clip will have when included in compositions. The argument ``pos`` can be either a couple ``(x,y)`` or a function ``t-> (x,y)``. `x` and `y` mark the location of the top left corner of the clip, and can be of several types. Examples -------- .. code:: python clip.with_position((45,150)) # x=45, y=150 # clip horizontally centered, at the top of the picture clip.with_position(("center","top")) # clip is at 40% of the width, 70% of the height: clip.with_position((0.4,0.7), relative=True) # clip's position is horizontally centered, and moving up ! clip.with_position(lambda t: ('center', 50+t)) r c>T$rr))r+r6s r,r-)VideoClip.with_position..sr/N)r7r%r6)rAr6relatives ` r,r#VideoClip.with_positions&8% 3 # #DH$DHr/cXlg)zSet the clip's layer in compositions. Clips with a greater ``layer`` attribute will be displayed on top of others. Note: Only has effect when the clip is used in a CompositeVideoClip. N)r8)rAindexs r,with_layer_indexVideoClip.with_layer_indexs !r/c :UR[UUUUS9/5$)zrReturns a video clip that is a resized version of the clip. For info on the parameters, please see ``vfx.Resize`` )new_sizerrr)rr)rArPrrrs r,resizedVideoClip.resizeds0  %!"/    r/angleunitresampleexpandr translaterc @UR[UUUUUUUS9/5$)zRotates the specified clip by ``angle`` degrees (or radians) anticlockwise If the angle is not a multiple of 90 (degrees) or ``center``, ``translate``, and ``bg_color`` are not ``None``. For info on the parameters, please see ``vfx.Rotate`` )rSrTrUrVrrWr)rr)rArSrTrUrVrrWrs r,rotatedVideoClip.rotated s9  %!!'%   r/x1y1x2y2rrx_centery_centerc BUR[UUUUUUUUS9/5$)a*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 cropped region. All coordinates are in pixels. Float numbers are accepted. For info on the parameters, please see ``vfx.Crop`` )r[r\r]r^rrr_r`)rr) rAr[r\r]r^rrr_r`s r,croppedVideoClip.cropped*s<"  !%%    r/c[URU5URUS9nU(a-URb URR U5UlU$)z Returns an ImageClip made out of the clip's frame at time ``t``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. r=r?)r$r:r=r4r&)rAr+rkr?r_s r,r&VideoClip.to_ImageClipMsFT^^A. xX . II2215HMr/cf^UR(aU$URU4Sj5nSUlU$)z.Return a mask a video clip made from the clip.c(>SUSS2SS2T4-S- $)Nrrer))rCcanals r,r-#VideoClip.to_mask..^sc!Q+>N8NQT8Tr/Tr=r)rArir_s ` r,to_maskVideoClip.to_maskYs- <<K++,TUH#H Or/c^UR(aURS5nSUlU$U$)z;Return a non-mask video clip made from the mask video clip.cZ[R"SSU-/-5RS5$)Nrerf)rgrhri)rCs r,r-"VideoClip.to_RGB..fs"BIIa39+o6==gFr/Frk)rAr_s r,to_RGBVideoClip.to_RGBbs0 <<++FH %H OKr/cSUlg)zLRemove the clip's audio. Return a copy of the clip with audio set to None. Nr1rFs r, without_audioVideoClip.without_audiops  r/c>[U[5(a,SSKJn URUR:XaSOSnU"X/US9$[ [U]U5$)Nrrchaincompose)method)rr$rrr<r2__add__)rAotherrrzrBs r,r{VideoClip.__add__xsN eY ' ' !% UZZ 7WYF)4-G GY-e44r/ct>[U[5(aSSKJn U"X//5$[[U]U5$)zj Implement the or (self | other) to produce a video with self and other placed side by side horizontally. r clips_arrayrr$rrr2__or__rAr|rrBs r,rVideoClip.__or__s6 eY ' ' P / /Y,U33r/cx>[U[5(aSSKJn U"U/U//5$[[U]U5$)zX Implement division (self / other) to produce a video with self placed on top of other. rrrrs r, __truediv__VideoClip.__truediv__s; eY ' ' P01 1Y,U33r/ct[U[5(d[$SSKJn UR U"U5/5$)zT Implement matrice multiplication (self @ other) to rotate a video by other degrees rr)rrNotImplementedmoviepy.video.fx.Rotaterr)rAnrs r, __matmul__VideoClip.__matmul__s1 !T""! !2  &)--r/c$URU5$)zY Implement the and (self & other) to produce a video with other used as a mask for self. r)rAr4s r,__and__VideoClip.__and__s ~~d##r/) r5r?r@r9r>r=r8r4r6r7r<)NFNT)rT)NNNTiDmediumNNiNTFNNbarN)NTr)Nrr)Ti"Vi r0)rNr)r()NrrrNN)r6)F)NNNT)degbicubicFNNN)NNNNNNNN)rTN)r)B__name__ __module__ __qualname____firstlineno____doc__r3propertyrGrLrPrrrUrbr\rrrmrrrrrrrrrrrr rrgndarrayrOrr+rrr.r3rrrkr?rr"rr#rMrQbooltuplerYrSrbr&rlrrrur{rrrr__static_attributes__ __classcell__rBs@r,r$r$-s9xTX $&&--, D "3%()<QR )L>SL>\              F"3%( )  5 4 4 .$$r/r$c"\rSrSrSrSSjrSrg) DataVideoClipiaC Class of video clips whose successive frames are functions of successive datasets Parameters ---------- data A list of datasets, each dataset being used for one frame of the clip data_to_frame A function d -> video frame, where d is one element of the list `data` fps Number of frames per second in the animation c ^UTlUTlUTlU4Sjn[R TUUS[ U5-U- US9 g)Ncl>TRTR[TRU-55$r) data_to_framedatarSrTr;s r,r9.DataVideoClip.__init__..frame_functions*%%diiDHHqL0A&BC Cr/r)r=r?r>)rrrTr$r3len)rArrrTr=r>r9s` r,r3DataVideoClip.__init__sP * D   3t9_s*/  r/)rrrTN)FTrrrrrr3rr)r/r,rrs   r/rc"\rSrSrSrSSjrSrg)UpdatedVideoClipiaQ Class of clips whose frame_function requires some objects to be updated. Particularly practical in science where some algorithm needs to make some steps before a new frame can be generated. UpdatedVideoClips have the following frame_function: .. code:: python def frame_function(t): while self.world.clip_t < t: world.update() # updates, and increases world.clip_t return world.to_frame() Parameters ---------- world An object with the following attributes: - world.clip_t: the clip's time corresponding to the world's state. - world.update() : update the world's state, (including increasing world.clip_t of one time step). - world.to_frame() : renders a frame depending on the world's state. is_mask True if the clip is a WxH mask with values in 0-1 duration Duration of the clip, in seconds NcN^^TTlUU4Sjn[RTXBUS9 g)Nc>TRRU:a,TR5 TRRU:aM,TR5$r)worldclip_tupdateto_frame)r+rArs r,r91UpdatedVideoClip.__init__..frame_functions?**##a' **##a'>># #r/r9r=r?)rr$r3)rArr=r?r9s`` r,r3UpdatedVideoClip.__init__s+  $  8  r/)r)FNrr)r/r,rrs B  r/rcV\rSrSrSrS SjrS Sjr\S Sj5r\S Sj5r Sr g) r$iaClass for non-moving VideoClips. A video clip originating from a picture. This clip will simply display the given picture at all times. Examples -------- >>> clip = ImageClip("myHouse.jpeg") >>> clip = ImageClip( someArray ) # a Numpy array represent Parameters ---------- img Any picture file (png, tiff, jpeg, etc.) as a string or a path-like object, or any array representing an RGB image (for instance a frame from a VideoClip). is_mask Set this parameter to `True` if the clip is a mask. transparent Set this parameter to `True` (default) if you want the alpha layer of the picture (if it exists) to be used as a mask. Attributes ---------- img Array representing the image of the clip. Nc6^[RXUS9 [T[R5(d [ T5m[ TR5S:XaTRSS:XaiU(aSTSS2SS2S4-S- mOhU(aSTSS2SS2S4-S- mONU(a-[STSS2SS2S4-S- SS 9Ul TSS2SS2SS24mOU(aSTSS2SS2S4-S- mU4S jUl TRSSSSS 2Ul TUl g) Nrerpr0rrrerTr7c>T$rr))r+imgs r,r-$ImageClip.__init__..@r/r1) r$r3rrgr imread_v2rr;r$r4r9r<r)rArr= transparent fromalphar?s ` r,r3ImageClip.__init__)s  48D#rzz**C.C syy>Q yy|q Aq!G ,s2CAq!G ,s2C )#Aq!G *T$rr))r+arrs r,r-+ImageClip.image_transform..`rr/)r:r;r<r9rrZrr])rArrr`anew_ars @r,rImageClip.image_transformTs  H*+IIbqM$B$' +DD)A}))*5E* r/cUcSS/nUH1n[XS5nUcMURU5n[XU5 M3 g)zTime-transformation filter. Applies a transformation to the clip's timeline (see Clip.time_transform). This method does nothing for ImageClips (but it may affect their masks or their audios). The result is still an ImageClip. Nr4r5)rZtime_transformr])rA time_funcrrr`rrs r,rImageClip.time_transformisI  (HDD)A}((3E* r/)r9rr4r<)FTFN)NTrNF) rrrrrr3rrrrrr)r/r,r$r$sADOS6 ++(++r/r$c0^\rSrSrSrSU4SjjrSrU=r$)r!i|awAn ImageClip showing just one color. Parameters ---------- size Size tuple (width, height) in pixels of the clip. color If argument ``is_mask`` is False, ``color`` indicates the color in RGB of the clip (default is black). If `is_mask`` is True, ``color`` must be a float between 0 and 1 (default is 1) is_mask Set to true if the clip will be used as a mask. c>UupVU(a0Xe4nUcSnOv[R"U5(d [S5eOOUcSnO<[US5(d [S5e[ U[ 5(a [S5eXe[ U54n[TU]![R"X%U-5RU5X4S9 g)Nrz*Color has to be a scalar when mask is truer __getitem__z$Color has to contain RGB of the clipz1 DEM&*&;&;''< ' #J"+:O - 1 - 1 !+&#'"7"7      ##8 #    FNk6K  1$ $r/)rrr)NNNNNNr;blackNNrrrrrrTNr)rrrrrrr3rrrrrSrrrr)r/r,rrsgRJ'  !%T)(T)l2 c2xc+ sCxc+Z2%r/rc h\rSrSrSrSSSSSSS S S S S . r\"S/5SSSSS.Sj5rSSjrSr g) BitmapClipizAClip made of color bitmaps. Mainly designed for testing purposes.)rerr)rrer)rrrer)rerere)Y>)ql))9)r@!) RGBOWrCDEFr?NF)rTr? color_dictr=c ^^ TcUceU(aUO URUl/nUHan/nUH1n URU V s/sHoRU PM sn 5 M3 UR[R"U55 Mc [R"U5m [ T 5UlTcUR U- mOUR T- n[RUUU 4SjUUS9 TUl gs sn f)akCreates a VideoClip object from a bitmap representation. Primarily used in the test suite. Parameters ---------- bitmap_frames A list of frames. Each frame is a list of strings. Each string represents a row of colors. Each color represents an (r, g, b) tuple. Example input (2 frames, 5x3 pixel size):: [["RRRRR", "RRBRR", "RRBRR"], ["RGGGR", "RGGGR", "RGGGR"]] fps The number of frames per second to display the clip at. `duration` will calculated from the total number of frames. If both `fps` and `duration` are set, `duration` will be ignored. duration The total duration of the clip. `fps` will be calculated from the total number of frames. If both `fps` and `duration` are set, `duration` will be ignored. color_dict A dictionary that can be used to set specific (r, g, b) values that correspond to the letters used in ``bitmap_frames``. eg ``{"A": (50, 150, 150)}``. Defaults to:: { "R": (255, 0, 0), "G": (0, 255, 0), "B": (0, 0, 255), "O": (0, 0, 0), # "O" represents black "W": (255, 255, 255), # "A", "C", "D", "E", "F" represent arbitrary colors "A": (89, 225, 62), "C": (113, 157, 108), "D": (215, 182, 143), "E": (57, 26, 252), } is_mask Set to ``True`` if the clip is going to be used as a mask. Nc&>T[UT-5$r)rS)r+rT frame_arrays r,r-%BitmapClip.__init__..s[QW%>r/r) DEFAULT_COLOR_DICTrVrrgrr total_framesr$r3rT) rA bitmap_framesrTr?rVr= frame_list input_frame output_framerowrrYs ` @r,r3BitmapClip.__init__sn("666(2*8O8O (KL"##$M__U%;$MN#   bhh|4 5 ) hhz*  , ;##h.C((3.H >  #%NsC9 c U=(d URn/nUR5HnUR/5 UH{nUSRS5 UH^n[UR 55[UR 55R [U55nUSS==U- ss'M` M} M U$)zReturns a valid bitmap list that represents each frame of the clip. If `color_dict` is not specified, then it will use the same `color_dict` that was used to create the clip. r1r)rV iter_framesrrkeysvaluesrLr)rArVbitmaprlinepixelletters r, to_bitmapBitmapClip.to_bitmaps  24?? %%'E MM" r !!"%!E!*//"34Z..0177e EF2JrNf,N "( r/)rVrTr\r) rrrrrr[rr3rkrr)r/r,r>r>sZK          ":,/$(4DRWO0Obr/r>)=rr\r[rrnumbersrtypingrrrrnumpyrgr imageio.v2rr imageio.v3r PILr r r !moviepy.video.io.ffplay_previewerr moviepy.Effectr moviepy.Cliprmoviepy.decoratorsrrrrrrrrr moviepy.toolsrrrmoviepy.video.fx.Croprmoviepy.video.fx.Resizerrrmoviepy.video.io.ffmpeg_writerr moviepy.video.io.gif_writersr"r$rrr$r!rr>r)r/r,r|s  77*++B%   LK&**=?|$|$~# I D, y, ^Ir+ r+j) ) XL%yL%^ttr/