W|hbSrSSKrSSKJr SSKJr SSKJr SSK J r J r SSK r SSKr\ (aSSKJr SSKJrJrJrJrJrJr "S S 5rg) zImplements the central object of MoviePy, the Clip, and all the methods that are common to the two subclasses of Clip, VideoClip and AudioClip. N)reduce)Real)add) TYPE_CHECKINGList)Effect)apply_to_audio apply_to_maskconvert_parameter_to_secondsoutplacerequires_durationuse_clip_fps_by_defaultcP\rSrSrSrSrSrSr\"S/5S5r S)S jr S*S jr S \ S 4S jr \\\"S/5\S+Sj5555r\\\"S/5\S5555r\\\"S/5\S+Sj5555r\S5rS,Sjr\S5r\S5r\"SS/5\\S-Sj555r\"SS/5S5rS.S\S\4SjjrS.S\4Sjjr\\S/Sj55r\"S/5S5r S r!S!r"S"r#S#r$S$r%S%r&S&r'S'r(S(r)g)0ClipaBase class of all clips (VideoClips and AudioClips). Attributes ---------- start : float When the clip is included in a composition, time of the composition at which the clip starts playing (in seconds). end : float When the clip is included in a composition, time of the composition at which the clip stops playing (in seconds). duration : float Duration of the clip (in seconds). Some clips are infinite, in this case their duration will be ``None``. TEMP_MPY_cXSUlSUlSUlSUlSUlSUlg)NrF)startenddurationmemoize memoized_tmemoized_frameselfs F/home/james-whalen/.local/lib/python3.13/site-packages/moviepy/Clip.py__init__ Clip.__init__5s-   "c.[R"U5$)zGAllows the usage of ``.copy()`` in clips as chained methods invocation.)_copycopyrs rr" Clip.copy>szz$rtcUR(a:XR:Xa UR$URU5nXlX lU$URU5$)zGets a numpy array representing the RGB picture of the clip, or (mono or stereo) value for a sound clip, at time ``t``. Parameters ---------- t : float or tuple or str Moment of the clip whose frame will be returned. )rrrframe_function)rr$frames r get_frameClip.get_frameBsR <<OO#***++A."#&+# &&q) )rNc^^Uc/nTRUU4Sj5nU(dSUlSUl[U[5(aU/nUH0n[ XES5nUcMUR TUS9n[XEU5 M2 U$)anGeneral processing of a clip. Returns a new Clip whose frames are a transformation (through function ``func``) of the frames of the current clip. Parameters ---------- func : function A function with signature (gf,t -> frame) where ``gf`` will represent the current clip's ``get_frame`` method, i.e. ``gf`` is a function (t->image). Parameter `t` is a time in seconds, `frame` is a picture (=Numpy array) which will be returned by the transformed clip (see examples below). apply_to : {"mask", "audio", ["mask", "audio"]}, optional Can be either ``'mask'``, or ``'audio'``, or ``['mask','audio']``. Specifies if the filter should also be applied to the audio or the mask of the clip, if any. keep_duration : bool, optional Set to True if the transformation does not change the ``duration`` of the clip. Examples -------- In the following ``new_clip`` a 100 pixels-high clip whose video content scrolls from the top to the bottom of the frames of ``clip`` at 50 pixels per second. >>> filter = lambda get_frame,t : get_frame(t)[int(t):int(t)+50, :] >>> new_clip = clip.transform(filter, apply_to='mask') Nc*>T"TRU5$N)r()r$funcrs r Clip.transform..sd4>>ST>Ur keep_duration)with_updated_frame_functionrr isinstancestrgetattr transformsetattr)rr-apply_tor1new_clip attributeattribute_valuenew_attribute_values`` rr6Clip.transformYsJ  H334UV $H HL h $ $ zH!I%h4@O*&5&?&? '@'#-@A "rc8^Uc/nURU4SjUUS9$)aT Returns a Clip instance playing the content of the current clip but with a modified timeline, time ``t`` being replaced by the return of `time_func(t)`. Parameters ---------- time_func : function A function ``t -> new_t``. apply_to : {"mask", "audio", ["mask", "audio"]}, optional Can be either 'mask', or 'audio', or ['mask','audio']. Specifies if the filter ``transform`` should also be applied to the audio or the mask of the clip, if any. keep_duration : bool, optional ``False`` (default) if the transformation modifies the ``duration`` of the clip. Examples -------- .. code:: python # plays the clip (and its mask and sound) twice faster new_clip = clip.time_transform(lambda t: 2*t, apply_to=['mask', 'audio']) # plays the clip starting at t=3, and backwards: new_clip = clip.time_transform(lambda t: 3-t) c >U"T"U55$r,)r(r$ time_funcs rr.%Clip.time_transform..s9Q>> new_clip = clip.with_effects([vfx.Resize(0.2, method="bilinear")]) You can also pass multiple effect as a list >>> clip.with_effects([afx.VolumeX(0.5), vfx.Resize(0.3), vfx.Mirrorx()]) )r"apply)rrEr9effect effect_copys r with_effectsClip.with_effectss=99;F!++-K"((2H  rcXlURbU(aXR-UlgURbURUR- Ulgg)aRReturns a copy of the clip, with the ``start`` attribute set to ``t``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. These changes are also applied to the ``audio`` and ``mask`` clips of the current clip, if they exist. note:: The start and end attribute of a clip define when a clip will start playing when used in a composite video clip, not the start time of the clip itself. i.e: with_start(10) mean the clip will still start at his first frame, but if used in a composite video clip it will only start to show at 10 seconds. Parameters ---------- t : float or tuple or str New ``start`` attribute value for the clip. change_end : bool optional Indicates if the ``end`` attribute value must be changed accordingly, if possible. If ``change_end=True`` and the clip has a ``duration`` attribute, the ``end`` attribute of the clip will be updated to ``start + duration``. If ``change_end=False`` and the clip has a ``end`` attribute, the ``duration`` attribute of the clip will be updated to ``end - start``. N)rrr)rr$ change_ends r with_startClip.with_startsGF MM %:==(DH XX ! HHtzz1DM"rcXlURcgURc,URb[SXR- 5UlggURUR- Ulg)aReturns a copy of the clip, with the ``end`` attribute set to ``t``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. Also sets the duration of the mask and audio, if any, of the returned clip. note:: The start and end attribute of a clip define when a clip will start playing when used in a composite video clip, not the start time of the clip itself. i.e: with_start(10) mean the clip will still start at his first frame, but if used in a composite video clip it will only start to show at 10 seconds. Parameters ---------- t : float or tuple or str New ``end`` attribute value for the clip. Nr)rrrmax)rr$s rwith_end Clip.with_endsZ2 88   :: }}( A $56 )!HHtzz1DMrrcXlU(aUcSOURU-UlgURc [S5eURU- Ulg)aReturns a copy of the clip, with the ``duration`` attribute set to ``t``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. Also sets the duration of the mask and audio, if any, of the returned clip. If ``change_end is False``, the start attribute of the clip will be modified in function of the duration and the preset end of the clip. Parameters ---------- duration : float New duration attribute value for the clip. change_end : bool, optional If ``True``, the ``end`` attribute value of the clip will be adjusted accordingly to the new duration using ``clip.start + duration``. Nz2Cannot change clip start when new duration is None)rrr ValueError)rrrMs r with_durationClip.with_durationsI.!  ( 0t X8MDH}}$ !UVVH,DJrcXlg)zSets a ``frame_function`` attribute for the clip. Useful for setting arbitrary/complicated videoclips. Parameters ---------- frame_function : function New frame creator function for the clip. N)r&)rr&s rr2 Clip.with_updated_frame_function<s -rcU(a+SSKJn URU"XR- 5/5nOUR 5nXlU$)aReturns a copy of the clip with a new default fps for functions like write_videofile, iterframe, etc. Parameters ---------- fps : int New ``fps`` attribute value for the clip. change_duration : bool, optional If ``change_duration=True``, then the video speed will change to match the new fps (conserving all frames 1:1). For example, if the fps is halved in this mode, the duration will be doubled. r MultiplySpeed)moviepy.video.fx.MultiplySpeedr\rJfpsr")rr^change_durationr\newclips rwith_fps Clip.with_fpsIs=  D''sXX~)F(GHGiikG rcXlg)zSays whether the clip is a mask or not. Parameters ---------- is_mask : bool New ``is_mask`` attribute value for the clip. N)is_mask)rrds r with_is_maskClip.with_is_maskb  rcXlg)zSets whether the clip should keep the last frame read in memory. Parameters ---------- memoize : bool Indicates if the clip should keep the last frame read in memory. N)r)rrs r with_memoizeClip.with_memoizenrgr start_timeend_timecb^TS:aURT-mURb1TUR:a![ST-S-SUR--5eURU4Sj/S9nUcURb URnO>Ub;US:a5URc[S[TU45-5eURU-nUbhURb3X R- S:a![S U-S -SUR--5eUT- UlURUR-UlU$) aZReturns a clip playing the content of the current clip between times ``start_time`` and ``end_time``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. The ``mask`` and ``audio`` of the resulting subclip will be subclips of ``mask`` and ``audio`` the original clip, if they exist. It's equivalent to slice the clip as a sequence, like ``clip[t_start:t_end]``. Parameters ---------- start_time : float or tuple or str, optional Moment that will be chosen as the beginning of the produced clip. If is negative, it is reset to ``clip.duration + start_time``. end_time : float or tuple or str, optional Moment that will be chosen as the end of the produced clip. If not provided, it is assumed to be the duration of the clip (potentially infinite). If is negative, it is reset to ``clip.duration + end_time``. For instance: >>> # cut the last two seconds of the clip: >>> new_clip = clip.subclipped(0, -2) If ``end_time`` is provided or if the clip has a duration attribute, the duration of the returned clip is set automatically. rzstart_time (%.02f) z"should be smaller than the clip's zduration (%.02f).c>UT-$r,r@)r$rks rr.!Clip.subclipped..s Zrr8zZSubclip with negative times (here %s) can only be extracted from clips with a ``duration``g:0yE>zend_time (%.02f) z)should be smaller or equal to the clip's )rrUrCr4rrrrkrlr9s ` r subclippedClip.subclippedzsTD >3J MM %J$--,G% 267% 56  &&'?"&M  4==#<}}H"A}}$ PJ12 4 ==83   )==0H:0U '(2AB)DMM9: !): 5H #>>H,=,==HLrc^^URUU4SjSS/S9nURb!URURTT- - 5$U$)a Returns a clip playing the content of the current clip but skips the extract between ``start_time`` and ``end_time``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. If the original clip has a ``duration`` attribute set, the duration of the returned clip is automatically computed as `` duration - (end_time - start_time)``. The resulting clip's ``audio`` and ``mask`` will also be cutout if they exist. Parameters ---------- start_time : float or tuple or str Moment from which frames will be ignored in the resulting output. end_time : float or tuple or str Moment until which frames will be ignored in the resulting output. c>XT:TT- --$r,r@)r$rlrks rr.+Clip.with_section_cut_out..sa ?x*/DEEraudiomaskrp)rCrrVrqs `` rwith_section_cut_outClip.with_section_cut_outsU0&& Ev&'  == $))$--8j;P*QR ROrfactorfinal_durationc:SSKJn URU"XS9/5$)zReturns a clip playing the current clip but at a speed multiplied by ``factor``. For info on the parameters, please see ``vfx.MultiplySpeed``. rr[)r{r|)r]r\rJ)rr{r|r\s rwith_speed_scaledClip.with_speed_scaleds& A  & H I  rc<SSKJn URU"XUS9/5$)zReturns a new clip with audio volume multiplied by the value `factor`. For info on the parameters, please see ``afx.MultiplyVolume`` r)MultiplyVolume)r{rkrl)moviepy.audio.fx.MultiplyVolumerrJ)rr{rkrlrs rwith_volume_scaledClip.with_volume_scaleds( C  68 T U  rc #P# [R"U5nUR[R"S[ UR U-55S9HNnXQ- nURU5nUb!URU:waURU5nU(aXg4v MJUv MP g7f)aoIterates over all the frames of the clip. Returns each frame of the clip as a HxWxN Numpy array, where N=1 for mask clips and N=3 for RGB clips. This function is not really meant for video editing. It provides an easy way to do frame-by-frame treatment of a video, for fields like science, computer vision... Parameters ---------- fps : int, optional Frames per second for clip iteration. Is optional if the clip already has a ``fps`` attribute. with_times : bool, optional Ff ``True`` yield tuples of ``(t, frame)`` where ``t`` is the current time for the frame, otherwise only a ``frame`` object. logger : str, optional Either ``"bar"`` for progress bar or ``None`` or any Proglog logger. dtype : type, optional Type to cast Numpy array frames. Use ``dtype="uint8"`` when using the pictures to write video, images.. Examples -------- .. code:: python # prints the maximum of red that is contained # on the first line of each frame of the clip. from moviepy import VideoFileClip myclip = VideoFileClip('myvideo.mp4') print([frame[0,:,0].max() for frame in myclip.iter_frames()]) r) frame_indexN) proglogdefault_bar_loggeriter_barnparangeintrr(dtypeastype)rr^ with_timesloggerrrr$r's r iter_framesClip.iter_framessV++F3!?? !S)<%=>+ K !ANN1%E! u(< U+h  sB$B&c[U[R5(a}UR5UR 5p2UR bX R :agX0R :agSXR :-nUR bXAUR :*-nU$XR :=(a# UR SL=(d XR :$)abIf ``t`` is a time, returns true if t is between the start and the end of the clip. ``t`` can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. If ``t`` is a numpy array, returns False if none of the ``t`` is in the clip, else returns a vector [b_1, b_2, b_3...] where b_i is true if tti is in the clip. NF)r3rndarrayminrQrr)rr$tmintmaxresults r is_playingClip.is_playing9s a $ $!%%'$$488+;jj !zz/*Fxx#txx-'MOO488t+;*NXX Orcg)z&Release any resources that are in use.Nr@rs rclose Clip.closeTs rcF[U[5(d[$URUR-nURUR-nX#:wag[ UR 5UR 55H"upE[R"XE5(aM" g g)NFT) r3rNotImplementedrr^ziprr array_equal)rother self_length other_lengthframe1frame2s r__eq__ Clip.__eq__`s%&&! !mmdhh. ~~ 1  &"$"2"2"4e6G6G6IJNF>>&11KrcU$)zP Support the Context Manager protocol, to ensure that resources are cleaned up. r@rs r __enter__Clip.__enter__qs  rc$UR5 gr,)r)rexc_type exc_value tracebacks r__exit__ Clip.__exit__xs  rcR^^^SS/n[U[5(aTRUR=(d SUR=(d TR 5mUR (aw[UR 5mTS:wa6TRU4SjUSS9mTRSTR -T- 5mUR S:aTRUU4S jSUS 9mT$[U[5(a[[U4S jU55$TRU5$) a Support extended slice and index operations over a clip object. Simple slicing is implemented via `subclip`. So, ``clip[t_start:t_end]`` is equivalent to ``clip.subclipped(t_start, t_end)``. If ``t_start`` is not given, default to ``0``, if ``t_end`` is not given, default to ``self.duration``. The slice object optionally support a third argument as a ``speed`` coefficient (that could be negative), ``clip[t_start:t_end:speed]``. For example ``clip[::-1]`` returns a reversed (a time_mirror fx) the video and ``clip[:5:2]`` returns the segment from 0 to 5s accelerated to 2x (ie. resulted duration would be 2.5s) In addition, a tuple of slices is supported, resulting in the concatenation of each segment. For example ``clip[(:1, 2:)]`` return a clip with the segment from 1 to 2s removed. If ``key`` is not a slice or tuple, we assume it's a time value (expressed in any format supported by `cvsec`) and return the frame at that time, passing the key to ``get_frame``. rxrwrrc>TU-$r,r@)r$r{s rr."Clip.__getitem__..s &1*rT)r8r1g?cB>TRU- STR- - $)Nr)rr^)r$cliprs rr.rs$--!"3a$((l"Br)r1r8c3.># UH nTUv M g7fr,r@).0krs r #Clip.__getitem__..s5AQs)r3slicerrrstoprstepabsrCrVtuplerrr()rkeyr8rr{s` @@r __getitem__Clip.__getitem__{s8G$ c5 ! !??399>3883Lt}}MDxxSXXQ;..,xt/D --cDMM.AF.JKD88a<..B&*!)/D K U # ##556 6>>#& &rcgr,r@rs r__del__ Clip.__del__s rc[$r,)r)rrs r__add__ Clip.__add__srct[U[5(d[$SSKJn UR U"U5/5$)Nr)Loop)r3rrmoviepy.video.fx.LooprrJ)rnrs r__mul__ Clip.__mul__s/!T""! !.  $q'++r)rrr&rdrrrr)NT)NF)T)F)rN)NN)NFNN)*__name__ __module__ __qualname____firstlineno____doc___TEMP_FILES_PREFIXrr"r r(r6rCrrJr r r rNrRrVr2rarerirrryfloatr~rr rrrrrrrrrrr__static_attributes__r@rrrrs,%# "3%(*)*,:x( TDN$!3%( #2)#2J!3%( 2)2<!:,/ -0-8 - -2    "<"<=I>IV"<"<=>B  e   77r"3%(P)P4  "7'r ,rr)rr"r! functoolsrnumbersroperatorrtypingrrnumpyrrmoviepy.Effectrmoviepy.decoratorsr r r r r rrr@rrrs?&%j ,j ,r