old-parkingkoncept/parkingkonceptvenv/lib/python3.7/site-packages/matplotlib/__pycache__/animation.cpython-37.pyc

B
U<>]w
<00>@s<>dd
lZdd
l
Z
dd
lZddlmZmZ
dd
lZdd
lZdd
lZddl	m
Z

dd
lZdd
lZdd
l
Z
dd
lZddlmZ
dd
lZdd
lZdd
lZddlmZmZmZmZ
ddlmZmZmZmZ
e<07>e <20>
Z!e<0B>"<22>dkr<>dZ#Z$ndZ#d	d
<EFBFBD>Z%Gdd<0C>de&<26>Z'e'<27>Z(Gd
d<0E>dej)<29>Z*Gdd<10>de*<2A>Z+Gdd<12>de+<2B>Z,e(<28>-d<13>
Gdd<15>de+<2B><03>
Z.Gdd<17>de&<26>Z/e(<28>-d<18>
Gdd<1A>de/e+<2B><04>
Z0e(<28>-d<1B>
Gdd<1D>de/e,<2C><04>
Z1Gdd<1F>de/<2F>Z2e(<28>-d <20>
Gd!d"<22>d"e2e0<65><04>
Z3e(<28>-d#<23>
Gd$d%<25>d%e2e1<65><04>
Z4Gd&d'<27>d'e&<26>Z5e(<28>-d(<28>
Gd)d*<2A>d*e5e+<2B><04>
Z6e(<28>-d+<2B>
Gd,d-<2D>d-e5e,<2C><04>
Z7d.d/<2F>Z8d0d1<64>Z9e(<28>-d2<64>
Gd3d4<64>d4e,<2C><03>
Z:Gd5d6<64>d6e&<26>Z;Gd7d8<64>d8e;<3B>Z<Gd9d:<3A>d:e<<3C>Z=Gd;d<<3C>d<e<<3C>Z>d
S)=<3D>N)<02>BytesIO<49>
TextIOWrapper)
<01>Path)
<01>TemporaryDirectory)<04>DISPLAY_TEMPLATE<54>INCLUDED_FRAMES<45>
JS_INCLUDE<EFBFBD>
STYLE_INCLUDE)<04>cbook<6F>rcParams<6D>rcParamsDefault<6C>
rc_context<EFBFBD>WindowsicCsPd
d<02>}t|||<00>
||}t|
||<00>
||}||||<03>||||<03>fS)a#
Compute figure size so that pixels are a multiple of n

    Parameters
    ----------
    w, h : float
        Size in inches

    dpi : float
        The dpi

    n : int
        The target multiple

    Returns
    -------
    wnew, hnew : float
        The new figure size in inches.
    cSsvt||
<00>
|d
krrtt
<01>|t
j<03>|
<00>
|d
krBt
<01>|t
j<03>}n0tt
<01>|t
j<00>|
<00>
|d
krrt
<01>|t
j<00>}|S)Nr
)<04>int<6E>npZ	nextafter<65>inf)<03>
x<>dpi<70>
n<>r<00></tmp/pip-install-i8dhxrtk/matplotlib/matplotlib/animation.py<70>correct_roundoffTs



 

z*adjusted_figsize.<locals>.correct_roundoff)
r)<07>
w<>
hrrrZwnewZhnewrrr<00>adjusted_figsize>s

rc@sPeZ
dZd
Zdd<03>Zdd<05>Zdd<07>Zdd	<09>Zd
d<0B>Zdd
<0A>Z	dd<0F>Z
dd<11>ZdS)<13>MovieWriterRegistryz<Registry of available writer classes by human readable name.c

Cst<00>|_
t<00>|_d
|_dS)NF)<04>dict<63>avail<69>_registered<65>_dirty)
<01>selfrrr<00>__init__ds


zMovieWriterRegistry.__init__c

Cs
d
|_dS)z$Sets a flag to re-setup the writers.TN)
r)
r rrr<00>	set_dirtyiszMovieWriterRegistry.set_dirtycs<00><00>
fd
d<02>}|S)z<>Decorator for registering a class under a name.

        Example use::

            @registry.register(name)
            class Foo:
                pass
        c

s |<00>
j<00><|<00>
<01>r|<00>
j<02><|S)
N)r<00>isAvailabler)
<01>writerClass)<02>namer rr<00>wrappervs





z-MovieWriterRegistry.register.<locals>.wrapperr)r r%r&r)r%r r<00>registerms	zMovieWriterRegistry.registerc

Cs|jr|<00>
<01>
d
S)z2If dirty, reasks the writers if they are availableN)r<00>reset_available_writers)
r rrr<00>ensure_not_dirty}s
z$MovieWriterRegistry.ensure_not_dirtyc

Cs d
d<02>|j<00>
<01>D<00>
|_d|_dS)z3Reset the available state of all registered writersc
Ssi|]\}
}|<02><00>r||
<01>qSr)
r#)<03>.0r%r$rrr<00>
<dictcomp><3E>s

z?MovieWriterRegistry.reset_available_writers.<locals>.<dictcomp>FN)r<00>itemsrr)
r rrrr(<00>s
z+MovieWriterRegistry.reset_available_writersc

Cs|<00><00>
t
|j<02>
S)
z%Get a list of available MovieWriters.)r)<00>listr)
r rrrr-<00>s
zMovieWriterRegistry.listcCs|<00><00>
|
|j
kS)
z<>Check if given writer is available by name.

        Parameters
        ----------
        name : str

        Returns
        -------
        available : bool
        )r)r)r r%rrr<00>is_available<6C>s
z MovieWriterRegistry.is_availablecCsH|<00><00>
|j
std
<01>
<01>
y
|j
|
Stk
rB


td<02>|
<01>
<01>
<01>
YnXdS)NzNo MovieWriters available!z(Requested MovieWriter ({}) not available)r)r<00>RuntimeError<6F>KeyError<6F>format)r r%rrr<00>__getitem__<5F>s








zMovieWriterRegistry.__getitem__N)<0C>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__r!r"r'r)r(r-r.r2rrrrrbs

rc@sJeZ
dZd
Zejddd<04>
<01>
Zejdd<06><00>
Zejdd<08><00>
Ze	j
d	d
<EFBFBD><00>
ZdS)<0C>AbstractMovieWritera<72>
    Abstract base class for writing movies. Fundamentally, what a MovieWriter
    does is provide is a way to grab frames by calling grab_frame().

    setup() is called to start the process and finish() is called afterwards.

    This class is set up to provide for writing movie frame data to a pipe.
    saving() is provided as a context manager to facilitate this process as::

        with moviewriter.saving(fig, outfile='myfile.mp4', dpi=100):
            # Iterate over frames
            moviewriter.grab_frame(**savefig_kwargs)

    The use of the context manager ensures that setup() and finish() are
    performed as necessary.

    An instance of a concrete subclass of this class can be given as the
    ``writer`` argument of `Animation.save()`.
    Nc
Csd
S)a<>

        Perform setup for writing the movie file.

        Parameters
        ----------
        fig : `matplotlib.figure.Figure` instance
            The figure object that contains the information for frames
        outfile : string
            The filename of the resulting movie file
        dpi : int, optional
            The DPI (or resolution) for the file.  This controls the size
            in pixels of the resulting movie file. Default is ``fig.dpi``.
        Nr)r <00>fig<69>outfilerrrr<00>setup<75>szAbstractMovieWriter.setupc

Ksd
S)z<>
        Grab the image information from the figure and save as a movie frame.

        All keyword arguments in savefig_kwargs are passed on to the `savefig`
        command that saves the figure.
        Nr)r <00>savefig_kwargsrrr<00>
grab_frame<EFBFBD>szAbstractMovieWriter.grab_framec


Csd
S)z,Finish any processing for writing the movie.Nr)
r rrr<00>finish<73>szAbstractMovieWriter.finishcos0|j|
||f|<04>|<05>

z
|V
Wd
|<00>
<01>
Xd
S)z<>
        Context manager to facilitate writing the movie file.

        ``*args, **kw`` are any parameters that should be passed to `setup`.
        N)r:r=)r r8r9r<00>args<67>kwargsrrr<00>saving<6E>s


zAbstractMovieWriter.saving)
N)r3r4r5r6<00>abc<62>abstractmethodr:r<r=<00>
contextlib<EFBFBD>contextmanagerr@rrrrr7<00>s
	r7c@s<>eZ
dZd
Zddd<05>
Zedd<07><00>
Zdd	<09>Zdd
d<0B>
Zdd
<0A>Z	dd<0F>Z
dd<11>Zdd<13>Zdd<15>Z
dd<17>Zedd<19><00>
Zedd<1B><00>
ZdS)<1E>MovieWritera<72>
Base class for writing movies.

    This is a base class for MovieWriter subclasses that write a movie frame
    data to a pipe. You cannot instantiate this class directly.
    See examples for how to use its subclasses.

    Attributes
    ----------
    frame_format : str
        The format used in writing frame data, defaults to 'rgba'
    fig : `~matplotlib.figure.Figure`
        The figure to capture data from.
        This must be provided by the sub-classes.

    <20>NcCs<>|jt
krtd
<01>
<01>
|
|_d|_|dkr2td|_n||_|dkrLtd|_n||_|dkrltt|j	<00>
|_
n||_
|dkr<>t<0B>|_n||_dS)a<>MovieWriter

        Parameters
        ----------
        fps : int
            Framerate for movie.
        codec : string or None, optional
            The codec to use. If ``None`` (the default) the ``animation.codec``
            rcParam is used.
        bitrate : int or None, optional
            The bitrate for the saved movie file, which is one way to control
            the output file size and quality. The default value is ``None``,
            which uses the ``animation.bitrate`` rcParam.  A value of -1
            implies that the bitrate should be determined automatically by the
            underlying utility.
        extra_args : list of strings or None, optional
            A list of extra string arguments to be passed to the underlying
            movie utility. The default is ``None``, which passes the additional
            arguments in the ``animation.extra_args`` rcParam.
        metadata : Dict[str, str] or None
            A dictionary of keys and values for metadata to include in the
            output file. Some keys that may be of use include:
            title, artist, genre, subject, copyright, srcform, comment.
        zNMovieWriter cannot be instantiated directly. Please use one of its subclasses.<2E>rgbaNzanimation.codeczanimation.bitrate)
<0A>	__class__rE<00>	TypeError<6F>fps<70>frame_formatr<00>codec<65>bitrater-<00>args_key<65>
extra_argsr<00>metadata)r rJrLrMrOrPrrrr!<00>s"







zMovieWriter.__init__c
Cs*|j<00>
<01>\}
}t|
|j<00>
t||j<00>
fS)
z7A tuple ``(width, height)`` in pixels of a movie frame.)r8<00>get_size_inchesrr)r rrrrr<00>
frame_size6
s
zMovieWriter.frame_sizec
Cs<>|jd
krb|j
<01><02>\}
}t|
||jd<02>\}}|
|f||fksp|j
j||dd<04>
t<06>d|
|||<04>
n|j
<01><02>\}}tjd|j	<09><02>
||fS)N<>h264<36>T)
Zforwardz>figure size (inches) has been adjusted from %s x %s to %s x %s<>frame size in pixels is %s x %s)
rU)
rLr8rQrr<00>set_size_inches<65>_log<6F>info<66>debugrR)r ZwoZhorrrrr<00>_adjust_frame_size<
s









zMovieWriter._adjust_frame_sizecCs>||_|
|_
|d
kr|j
j}||_|<00><03>\|_|_|<00><06>
d
S)a<>

        Perform setup for writing the movie file.

        Parameters
        ----------
        fig : matplotlib.figure.Figure
            The figure object that contains the information for frames
        outfile : string
            The filename of the resulting movie file
        dpi : int, optional
            The DPI (or resolution) for the file.  This controls the size
            in pixels of the resulting movie file. Default is fig.dpi.
        N)r9r8rrZ<00>_w<5F>_h<5F>_run)r r8r9rrrrr:I
s




zMovieWriter.setupc
Cs4|<00><00>}
t
<01>d
|
<01>
tj}tj|
|||td<02>|_dS)Nz$MovieWriter.run: running command: %s)<04>stdin<69>stdout<75>stderr<72>
creationflags)<08>_argsrWrX<00>
subprocess<EFBFBD>PIPE<50>Popen<65>subprocess_creation_flags<67>_proc)r <00>commandrdrrrr]b
s




zMovieWriter._runc

Cs|<00><00>
d
S)z,Finish any processing for writing the movie.N)
<01>cleanup)
r rrrr=m
szMovieWriter.finishc
KsBt<00>
d
<01>

|j<02>|j|j<05>
|jj|<00><07>f
|j|j	d<02>|
<01><02>

dS)z<>
        Grab the image information from the figure and save as a movie frame.

        All keyword arguments in savefig_kwargs are passed on to the `savefig`
        command that saves the figure.
        z'MovieWriter.grab_frame: Grabbing frame.)r1rN)
rWrYr8rVr[r\<00>savefig<69>_frame_sinkrKr)r r;rrrr<q
s

zMovieWriter.grab_framec


Cs|jj
S)
z3Return the place to which frames should be written.)rgr^)
r rrrrk<00>
szMovieWriter._frame_sinkc

Cstd
<01>
S)z9Assemble list of utility-specific command-line arguments.z)args needs to be implemented by subclass.)
<01>NotImplementedError)
r rrrrb<00>
szMovieWriter._argsc
Cs<>|j<00>
<01>\}
}|<00><02><00><03>
tt|
<01>
<01>
<01><06>}
tt|<02>
<01>
<01><06>}|
r\t<07>|jj	rPt
jnt
jd
|
<01>
|r~t<07>|jj	rrt
jnt
jd|<02>
|jj	r<>t
<0A>|jj	|jj|
|<02><04>
dS)z>Clean-up and collect the process used to write the movie file.zMovieWriter stdout:
%szMovieWriter stderr:
%sN)rg<00>communicaterk<00>closerr<00>readrW<00>log<6F>
returncode<EFBFBD>logging<6E>WARNING<4E>DEBUGrc<00>CalledProcessErrorr>)r <00>out<75>errrrrri<00>
s












zMovieWriter.cleanupc

Cstt
|j<00>
S)
z<>
        Return the binary path to the commandline tool used by a specific
        subclass. This is a class method so that the tool can be looked for
        before making a particular MovieWriter subclass available.
        )<03>strr<00>exec_key)
<01>clsrrr<00>bin_path<74>
szMovieWriter.bin_pathc

Cst<00>
|<00><02><00>
d
k	S)zO
        Check to see if a MovieWriter subclass is actually available.
        N)<03>shutil<69>whichr{)
rzrrrr#<00>
szMovieWriter.isAvailable)rFNNNN)
N)r3r4r5r6r!<00>propertyrRrZr:r]r=r<rkrbri<00>classmethodr{r#rrrrrE<00>s

9
	rEc@sdeZ
dZd
Zdd<03>Zddd<08>
Zed	d
<EFBFBD><00>
Zejdd
<EFBFBD><00>
Zdd
<0A>Z	dd<0F>Z
dd<11>Zdd<13>Zdd<15>Z
dS)<17>FileMovieWriterzx`MovieWriter` for writing to individual files and stitching at the end.

    This must be sub-classed to be useful.
    c
Os tj
|f
|
<01>|<02>

td
|_dS)Nzanimation.frame_format)rEr!rrK)r r>r?rrrr!<00>
s

zFileMovieWriter.__init__N<5F>_tmpTcCsN|
|_||_
|d
kr|jj}||_|<00><03>
||_||_d|_t<07>|_d|_	d
S)a6Perform setup for writing the movie file.

        Parameters
        ----------
        fig : matplotlib.figure.Figure
            The figure to grab the rendered frames from.
        outfile : str
            The filename of the resulting movie file.
        dpi : number, optional
            The dpi of the output file. This, with the figure size,
            controls the size in pixels of the resulting movie file.
            Default is fig.dpi.
        frame_prefix : str, optional
            The filename prefix to use for temporary files.  Defaults to
            ``'_tmp'``.
        clear_temp : bool, optional
            If the temporary files should be deleted after stitching
            the final result.  Setting this to ``False`` can be useful for
            debugging.  Defaults to ``True``.

        Nr
z
%s%%07d.%s)
r8r9rrZ<00>
clear_temp<EFBFBD>temp_prefix<69>_frame_counterr-<00>_temp_names<65>fname_format_str)r r8r9r<00>frame_prefixr<78>rrrr:<00>
s








zFileMovieWriter.setupc


Cs|jS)
z<>
        Format (png, jpeg, etc.) to use for saving the frames, which can be
        decided by the individual subclasses.
        )
<01>
_frame_format)
r rrrrK<00>
szFileMovieWriter.frame_formatcCs"|
|jkr|
|_
n|jd
|_
dS)Nr
)<02>supported_formatsr<73>)r rKrrrrK<00>
s

c

Cs|j|j
|jfS)
N)r<>r<>rK)
r rrr<00>_base_temp_name<6D>
szFileMovieWriter._base_temp_namec
CsB|<00><00>|j
}
|j<02>|
<01>

t<04>d
|j
|
<01>
|j
d7_
t|
d<03>S)Nz7FileMovieWriter.frame_sink: saving frame %d to fname=%s<>
<00>wb)r<>r<>r<><00>appendrWrY<00>open)r <00>fnamerrrrk<00>
s



zFileMovieWriter._frame_sinkc
	Ks@t<00>
d
<01>

|<00><02><00>$}|jj|f
|j|jd<02>|
<01><02>

WdQRXdS)z<>
        Grab the image information from the figure and save as a movie frame.
        All keyword arguments in savefig_kwargs are passed on to the `savefig`
        command that saves the figure.
        z'MovieWriter.grab_frame: Grabbing frame.)r1rN)rWrYrkr8rjrKr)r r;Zmyframesinkrrrr<<00>
s



zFileMovieWriter.grab_framec

Cs|<00><00>
t
<01>|<00>

dS)
N)r]rEr=)
r rrrr=s
zFileMovieWriter.finishc
Cs<t<00>
|<00>

|jr8t<03>d
|j<05>
x|jD]}
t<06>|
<01>

q&WdS)Nz)MovieWriter: clearing temporary fnames=%s)rErir<>rWrYr<><00>os<6F>remove)r r<>rrrris





zFileMovieWriter.cleanup)Nr<4E>T)r3r4r5r6r!r:r~rK<00>setterr<72>rkr<r=rirrrrr<><00>
s


#r<>ZpillowcsBeZ
dZed
d<02><00>
Z<04>f
dd<04>Zddd<07>
Zdd	<09>Zd
d<0B>Z<08>Z	S)
<0A>PillowWriterc
Cs&yd
dl}
Wnt
k
r 


dSXdS)Nr
FT)<02>PIL<49>ImportError)rzr<>rrrr#s




zPillowWriter.isAvailablec
s(|<02>d
<01>
dkrd|d
<t
<01>j|
|<02>

dS)NrOr)<03>get<65>superr!)r r>r?)
rHrrr!'s


zPillowWriter.__init__NcCsg|_||_
||_|
|_dS)
N)<04>_frames<65>_outfileZ_dpi<70>_fig)r r8r9rrrrr:,s



zPillowWriter.setupc
Ksdd
dlm
}
t<02>}|jj|f
t|
dd<04><02>

|jj<06><07>}|j<08>	|<02>
dt|j<0C>
t|j
<0A>
f|<03><0E><00><03>

dS)Nr
)
<01>ImagerG)
r1ZRGBA)r<>r<>rr<>rjr<00>canvasZget_rendererr<72>r<>Z	frombytesr<00>width<74>height<68>getvalue)r r;r<><00>bufZrendererrrrr<2s







zPillowWriter.grab_framec

Cs4|jd
j
|jd|jdd<00>td|j<00>
d
d<05>
dS)Nr
Tr<54>i<>)Zsave_allZ
append_images<65>duration<6F>loop)r<><00>saver<65>rrJ)
r rrrr=>s



zPillowWriter.finish)
N)
r3r4r5rr#r!r:r<r=<00>
__classcell__rr)
rHrr<>s

r<>cs8eZ
dZd
ZdZdZedd<05><00>
Ze<08>f
dd<07><08>
Z	<09>Z
S)<08>
FFMpegBasez<EFBFBD>Mixin class for FFMpeg output.

    To be useful this must be multiply-inherited from with a
    `MovieWriterBase` sub-class.
    zanimation.ffmpeg_pathzanimation.ffmpeg_argsc
Cs<>d
|jg}
|jdkr,d|j
kr,|
<01>ddg<02>

|jdkrJ|
<01>dd|jg<02>

|j
r\|
<01>|j
<01>

x,|j<04><05>D]\}}|
<01>dd	||fg<02>

qhW|
d
|jgS)Nz-vcodecrSz-pix_fmtZyuv420pr
z-bz%dkz	-metadataz%s=%sz-y)rLrO<00>extendrMrPr,r9)r r><00>
k<>
vrrr<00>output_argsPs







zFFMpegBase.output_argsc

s,t<00><00>
<01>o*d
tj|<00><04>g
ttjtjd<02>jkS)NsLibAv)rar_r`)	r<>r#rc<00>runr{rf<00>DEVNULLrdr`)
rz)
rHrrr#ds



zFFMpegBase.isAvailable)r3r4r5r6ryrNr~r<>rr#r<>rr)
rHrr<>Fs

r<>Zffmpegc@seZ
dZd
Zdd<03>ZdS)<05>FFMpegWriterzwPipe-based ffmpeg writer.

    Frames are streamed directly to ffmpeg via a pipe and written in a single
    pass.
    c
Cs\|<00><00>d
ddddd|j
d|jdt|j<04>
g}
t<05><06>tjkrF|
dd	g7}
|
d
dg|j	7}
|
S)Nz-fZrawvideoz-vcodecz-sz%dx%dz-pix_fmtz-rz	-loglevel<65>errorz-izpipe:)
r{rRrKrxrJrW<00>getEffectiveLevelrrrtr<>)r r>rrrrbws




zFFMpegWriter._argsN)r3r4r5r6rbrrrrr<>ps
r<>Zffmpeg_filec	@s.eZ
dZd
Zdddddddd	d
g	Zdd<0C>Zd
S)<0E>FFMpegFileWriterz}File-based ffmpeg writer.

    Frames are written to temporary files on disk and then stitched
    together at the end.

    <20>png<6E>jpeg<65>ppm<70>tiff<66>sgi<67>bmp<6D>pbm<62>rawrGc

Cs,|<00><00>d
t
|j<02>
d|<00><03>dt
|j<04>
g|jS)Nz-rz-iz-vframes)r{rxrJr<>r<>r<>)
r rrrrb<00>s

zFFMpegFileWriter._argsN)r3r4r5r6r<>rbrrrrr<><00>s


r<>c@s$eZ
dZd
ZdZdZeejj	<09>
ZdS)<05>
AVConvBasez<EFBFBD>Mixin class for avconv output.

    To be useful this must be multiply-inherited from with a
    `MovieWriterBase` sub-class.
    zanimation.avconv_pathzanimation.avconv_argsN)
r3r4r5r6ryrNrrEr#<00>__func__rrrrr<><00>s
r<>Zavconvc
@seZ
dZd
ZdS)<03>AVConvWriterzwPipe-based avconv writer.

    Frames are streamed directly to avconv via a pipe and written in a single
    pass.
    N)r3r4r5r6rrrrr<><00>sr<>Zavconv_filec
@seZ
dZd
ZdS)<03>AVConvFileWriterz|File-based avconv writer.

    Frames are written to temporary files on disk and then stitched
    together at the end.
    N)r3r4r5r6rrrrr<><00>sr<>csTeZ
dZd
ZdZdZedd<05><00>
Zedd<07><00>
Ze	<09>f
dd	<09><08>
Z
e	<09>f
d
d<0B><08>
Z<0B>ZS)<0C>ImageMagickBasez<65>Mixin class for ImageMagick output.

    To be useful this must be multiply-inherited from with a
    `MovieWriterBase` sub-class.
    zanimation.convert_pathzanimation.convert_argsc

Cs
d
|jS)NgY@)
rJ)
r rrr<00>delay<61>szImageMagickBase.delayc


Cs|jg
S)
N)
r9)
r rrrr<><00>szImageMagickBase.output_argsc
s"t<00><00>
<01>}
|
d
krt<02>d<02>
j}
|
S)N<>convertZmagick)r<>r{<00>mplZ_get_executable_info<66>
executable)rzZbinpath)
rHrrr{<00>s



zImageMagickBase.bin_pathc

s$y
t<00><00>
<01>Stk
r


d
SXdS)NF)r<>r#<00>FileNotFoundError)
rz)
rHrrr#<00>s



zImageMagickBase.isAvailable)
r3r4r5r6ryrNr~r<>r<>rr{r#r<>rr)
rHrr<><00>s
r<>Zimagemagickc@seZ
dZd
Zdd<03>ZdS)<05>ImageMagickWriterz|Pipe-based animated gif.

    Frames are streamed directly to ImageMagick via a pipe and written
    in a single pass.

    c

Cs4|<00><00>d
d|j
dddt|j<03>
ddd|jg
|jS)	Nz-sizez%ix%iz-depth<74>
8z-delayz-loop<6F>
0z%s:-)r{rRrxr<>rKr<>)
r rrrrb<00>s






zImageMagickWriter._argsN)r3r4r5r6rbrrrrr<><00>s
r<>Zimagemagick_filec	@s.eZ
dZd
Zdddddddd	d
g	Zdd<0C>Zd
S)<0E>ImageMagickFileWriterz<72>File-based animated gif writer.

    Frames are written to temporary files on disk and then stitched
    together at the end.

    r<>r<>r<>r<>r<>r<>r<>r<>rGc

Cs,|<00><00>d
t
|j<02>
ddd|j|jfg|jS)Nz-delayz-loopr<70>z%s*.%s)r{rxr<>r<>rKr<>)
r rrrrb<00>s


zImageMagickFileWriter._argsN)r3r4r5r6r<>rbrrrrr<><00>s

r<>cCs tj
t|<00>
tj<04>|d
<00>
|
d<02>S)z(frame_list should be a list of filenamesr
)<03>Nframes<65>	frame_dirrK)rr1<00>lenr<6E><00>path<74>dirname)<02>
frame_listrKrrr<00>_included_framess


r<>cs&d
<01>
dd<03><00><00>
fdd<05>t
|<00>
D<00>
<01>
S)z7frame_list should be a list of base64-encoded png filesz,  frames[{0}] = "data:image/{1};base64,{2}"
<EFBFBD>

<EFBFBD>c
	3s(|] \}
}<02>
<01>|
<01>|<02>
dd
<01><02>V
qdS)r<>z\
N)r1<00>replace)r*<00>
iZ
frame_data)rK<00>templaterr<00>	<genexpr>s
z#_embedded_frames.<locals>.<genexpr>)<02>join<69>	enumerate)r<>rKr)rKr<>r<00>_embedded_framess


r<><00>htmlcs\eZ
dZd
dddgZdZedd<07><00>
Zd<14>f
dd
<0A>	Zd<15>f
dd<0F>	Z<08>f
dd<11>Z	dd<13>Z
<EFBFBD>ZS)<16>
HTMLWriterr<EFBFBD>r<>r<><00>svgzanimation.html_argsc


Csd
S)NTr)
rzrrrr#szHTMLWriter.isAvailable<6C>NFr<46>c		sj||_|<07>
<01>|_|dkr$td
|_n||_|jd9_|jdkrRtd<04>|j<02>
<01>
<01>
t<07><00>|
||||<05>
dS)Nzanimation.embed_limiti)r<><00>onceZreflectzunrecognized default_mode {!r})	<09>embed_frames<65>lower<65>default_moder<00>_bytes_limit<69>
ValueErrorr1r<>r!)	r rJrLrMrOrPr<>r<><00>embed_limit)
rHrrr!s





zHTMLWriter.__init__cs<>tj
<01>|<02>
\}}|d
kr td<02>
<01>
g|_d|_d|_|jsn|dkrH|d}tj
<01>|<04>
s^t<00>	|<04>

tj
<01>
|d<06>}nd}t<0B>j|
|||dd<07>
dS)N)z.htmlz.htmzoutfile must be *.htm or *.htmlr
Fr<46><00>frame)
r<>)
r<>r<><00>splitextr<74><00>
_saved_frames<65>_total_bytes<65>
_hit_limitr<EFBFBD><00>exists<74>makedirsr<73>r<>r:)r r8r9rr<><00>root<6F>extr<74>)
rHrrr:2s










zHTMLWriter.setupc
s<>|jr<>|j
rdSt<02>}|jj|f
|j|jd
<01>|
<01><02>

t<07>|<02>	<09><00>
<01>
d<02>
}|jt|<03>
7_|j|j
kr<>t<0E>d|j|j
<0A>
d|_
q<>|j<10>|<03>

nt<12>jf|
<01>
SdS)N)r1r<00>asciiz<69>Animation size has reached %s bytes, exceeding the limit of %s. If you're sure you want a larger animation embedded, set the animation.embed_limit rc parameter to a larger value (in MB). This and further frames will be dropped.T)r<>r<>rr8rjrKr<00>base64<36>encodebytesr<73><00>decoder<65>r<>r<>rW<00>warningr<67>r<>r<>r<)r r;<00>
fZ	imgdata64)
rHrrr<Fs










zHTMLWriter.grab_framec

Cs<>|jr t
|j|j<03>}
t|j<02>
}nt|j|j<03>}
t|j<06>
}td
d
d
d<02>}d||jd<d|j	}t
|jd<06><02>:}|<05>t
t<00>

|<05>tjft<11><12>j||
|d<07>|<03><02>
<01>

WdQRXdS)Nr<4E>)Zonce_checkedZloop_checkedZreflect_checked<65>checkedZ_checkedi<64>r)<04>idr<64><00>fill_frames<65>interval)r<>r<>r<>rKr<>r<>r<>rr<>rJr<>r9<00>writerr	rr1<00>uuidZuuid4<64>hex)r r<>r<>Z	mode_dictr<74>Zofrrrr=]s&
















zHTMLWriter.finish)r<>NNNNFr<46>N)
N)r3r4r5r<>rNrr#r!r:r<r=r<>rr)
rHrr<>s


r<>c	@s<>eZ
dZd
Zd.dd<05>
Zdd<07>Zdd	<09>Zd/dd
<EFBFBD>
dd<0C>Zd
d<0E>Zdd<10>Z	dd<12>Z
dd<14>Zdd<16>Zdd<18>Z
dd<1A>Zdd<1C>Zdd<1E>Zdd <20>Zd!d"<22>Zd#d$<24>Zd%d&<26>Zd0d'd(<28>
Zd1d*d+<2B>
Zd,d-<2D>ZdS)2<>	Animationa"This class wraps the creation of an animation using matplotlib.

    It is only a base class which should be subclassed to provide
    needed behavior.

    This class is not typically used directly.

    Parameters
    ----------
    fig : matplotlib.figure.Figure
       The figure object that is used to get draw, resize, and any
       other needed events.

    event_source : object, optional
       A class that can run a callback when desired events
       are generated, as well as be stopped and started.

       Examples include timers (see :class:`TimedAnimation`) and file
       system notifications.

    blit : bool, optional
       controls whether blitting is used to optimize drawing.  Defaults
       to ``False``.

    See Also
    --------
    FuncAnimation,  ArtistAnimation

    NFcCs\|
|_|o|
j
j|_|<00><04>|_||_|
j
<01>d
|j<08>|_	|jj
<01>d|j
<EFBFBD>|_|jrX|<00><0C>
dS)N<>
draw_eventZclose_event)
r<>r<>Z
supports_blit<69>_blit<69>
new_frame_seq<65>	frame_seq<65>event_source<63>mpl_connect<63>_start<72>_first_draw_id<69>_stop<6F>	_close_id<69>_setup_blit)r r8r<><00>blitrrrr!<00>s







zAnimation.__init__c
Gs:|jj
<01>|j<03>

d
|_|<00><04>
|j<05>|j<07>

|j<05><08>
d
S)z<>
        Starts interactive animation. Adds the draw frame command to the GUI
        handler, calls show to start the event loop.
        N)	r<>r<><00>mpl_disconnectr<74><00>
_init_drawr<EFBFBD><00>add_callback<63>_step<65>start)r r>rrrr<><00>s


zAnimation._startc
Gs>|jr|j
j<02>|j<04>

|j
j<02>|j<05>

|j<06>|j<08>

d|_dS)
N)	r<>r<>r<>r
<00>
_resize_idr

r<><00>remove_callbackr
)r r>rrrr
<00>s




zAnimation._stop)
<01>progress_callbackc

s<>|d
krtd}n.t
|t<02>s@tdd<04>|||||fD<00>
<01>
r@td<05>
<01>
|
d
krLi}
<EFBFBD>jd
k	rl<72>jj<07><08>j<05>

d}nd}|d
kr<>t	<09>d<08>r<>d	<09>j
}|d
kr<>td
}|dkr<><72>jj}|d
kr<>td}|d
kr<>td
}<06>g
}
|	d
k	r<>|
<0A><0C>f
dd<04>|	D<00>
<01>

t
|t<02><02>
rf|t
jk<06>
r"t
||||||d<0F>}nDt
<0A><0F><00>
r^t
t
<0A><0F>d}t<10>d||<0E>
||||||d<0F>}ntd<12>
<01>
t<10>dt|<02>
<01>
d|
k<06>
r<>t<10>d<15>

|
<EFBFBD>d<14>

t<16><00><>
tddk<02>
r<>t<10>d<18>

d
td<|<02><17>j|
|<04><03><>
x|
D]}|<0F><18>
<00>
q<>Wd}dd<1A>|
D<00>
}d
|k<06>rd
}nt|<11>
}xltdd<1A>|
D<00>
<01>D]V}xBt|
|<13>D]4\}}|j|dd<1C>
|d
k	<09>r4|||<12>
|d7}<10>q4W|jf|
<EFBFBD>

<00>q$WWd
QRXWd
QRX|<0C>r<><72>jj<07>d<1E>j<1E><02>_d
S)a<>
        Save the animation as a movie file by drawing every frame.

        Parameters
        ----------

        filename : str
            The output filename, e.g., :file:`mymovie.mp4`.

        writer : :class:`MovieWriter` or str, optional
            A `MovieWriter` instance to use or a key that identifies a
            class to use, such as 'ffmpeg'. If ``None``, defaults to
            :rc:`animation.writer` = 'ffmpeg'.

        fps : number, optional
           Frames per second in the movie. Defaults to ``None``, which will use
           the animation's specified interval to set the frames per second.

        dpi : number, optional
           Controls the dots per inch for the movie frames.  This combined with
           the figure's size in inches controls the size of the movie.  If
           ``None``, defaults to :rc:`savefig.dpi`.

        codec : str, optional
           The video codec to be used. Not all codecs are supported
           by a given :class:`MovieWriter`. If ``None``, default to
           :rc:`animation.codec` = 'h264'.

        bitrate : number, optional
           Specifies the number of bits used per second in the compressed
           movie, in kilobits per second. A higher number means a higher
           quality movie, but at the cost of increased file size. If ``None``,
           defaults to :rc:`animation.bitrate` = -1.

        extra_args : list, optional
           List of extra string arguments to be passed to the underlying movie
           utility. If ``None``, defaults to :rc:`animation.extra_args`.

        metadata : Dict[str, str], optional
           Dictionary of keys and values for metadata to include in
           the output file. Some keys that may be of use include:
           title, artist, genre, subject, copyright, srcform, comment.

        extra_anim : list, optional
           Additional `Animation` objects that should be included
           in the saved movie file. These need to be from the same
           `matplotlib.figure.Figure` instance. Also, animation frames will
           just be simply combined, so there should be a 1:1 correspondence
           between the frames from the different animations.

        savefig_kwargs : dict, optional
           Is a dictionary containing keyword arguments to be passed
           on to the `savefig` command which is called repeatedly to
           save the individual frames.

        progress_callback : function, optional
            A callback function that will be called for every frame to notify
            the saving progress. It must have the signature ::

                def func(current_frame: int, total_frames: int) -> Any

            where *current_frame* is the current frame number and
            *total_frames* is the total number of frames to be saved.
            *total_frames* is set to None, if the total number of frames can
            not be determined. Return values may exist but are ignored.

            Example code to write the progress to stdout::

                progress_callback =                    lambda i, n: print(f'Saving frame {i} of {n}')

        Notes
        -----
        *fps*, *codec*, *bitrate*, *extra_args* and *metadata* are used to
        construct a `.MovieWriter` instance and can only be passed if
        *writer* is a string.  If they are passed as non-*None* and *writer*
        is a `.MovieWriter`, a `RuntimeError` will be raised.

        Nzanimation.writerc
ss|]}
|
dk	V
qdS)
Nr)r*<00>argrrrr<>s
z!Animation.save.<locals>.<genexpr>z<>Passing in values for arguments fps, codec, bitrate, extra_args, or metadata is not supported when writer is an existing MovieWriter instance. These should instead be passed as arguments when creating the MovieWriter instance.TF<54>	_intervalg@<40>@zsavefig.dpi<70>figurezanimation.codeczanimation.bitratec
3s|]}
|
j<00>jkr|
V
qdS)
N)
r<>)r*<00>anim)
r rrr<>Es

)rOrPr
z5MovieWriter %s unavailable; trying to use %s instead.zZCannot save animation: no writers are available. Please install ffmpeg to save animations.zAnimation.save using %sZbbox_inchesz<73>Warning: discarding the 'bbox_inches' argument in 'savefig_kwargs' as it may cause frame size to vary, which is inappropriate for animation.zsavefig.bboxZtightzkDisabling savefig.bbox = 'tight', as it may cause frame size to vary, which is inappropriate for animation.c
Ssg|]}
t|
dd
<01><03>qS)<02>
save_countN)
<01>getattr)r*<00>
arrr<00>
<listcomp>ws
z"Animation.save.<locals>.<listcomp>c
Ssg|]}
|
<01><00><00>qSr)
<01>new_saved_frame_seq)r*r
rrrr
}s)
r
r<>r<>)r<00>
isinstancerx<00>anyr/r<>r<>r<>r
<00>hasattrr

rr<><00>writersrr-rWr<>r<>rX<00>type<70>popr
r@r
<00>sum<75>zip<69>_draw_next_framer<r<>r<>)r <00>filename<6D>writerrJrrLrMrOrPZ
extra_animr;r
Zreconnect_first_drawZall_animZ
alt_writerr
Zframe_numberZsave_count_listZtotal_frames<65>data<74>
dr)
r rr<><00>s<>T






















































&


zAnimation.savec
Gs6yt|j
<01>
}|<00>||j<03>
d
Stk
r0


dSXdS)z<>
        Handler for getting events. By default, gets the next frame in the
        sequence and hands the data off to be drawn.
        TFN)<05>nextr<74>r
r<><00>
StopIteration)r r><00>	framedatarrrr
<00>s





zAnimation._stepc

Cs
t|j
<01>
S)
z+Return a new sequence of frame information.)<02>iter<65>
_framedata)
r rrrr<><00>szAnimation.new_frame_seqc

Cs|<00><00>S)
z8Return a new sequence of saved/cached frame information.)
r<>)
r rrrr
<00>szAnimation.new_saved_frame_seqcCs&|<00>|
|<02>
|<00>
|
<01>

|<00>|
|<02>
dS)
N)<03>	_pre_draw<61>_draw_frame<6D>
_post_draw)r r$
r
rrrr
<00>s


zAnimation._draw_next_framec


CsdS)
Nr)
r rrrr
<00>szAnimation._init_drawcCs|r|<00>|j
|j<02>
dS)
N)<03>_blit_clear<61>_drawn_artists<74>_blit_cache)r r$
r
rrrr'
<00>s
zAnimation._pre_drawcCstd
<01>
<01>
dS)NzDNeeds to be implemented by subclasses to actually make an animation.)
rl)r r$
rrrr(
<00>szAnimation._draw_framecCs,|r|jr|<00>
|j|j<02>
n|jj<04><05>
dS)
N)r+
<00>
_blit_drawr,
r<>r<><00>	draw_idle)r r$
r
rrrr)
<00>s

zAnimation._post_drawcCsrg}xF|
D]>}|j|kr0|j
j<02>|jj<04>
||j<|j<00>|<04>

|<03>|j<00>

q
Wx t|<03>
D]}|j
j<02>|j<04>

qVWdS)
N)	<09>axesr
r<>Zcopy_from_bboxZbboxZdraw_artistr<74><00>setr
)r <00>artists<74>bg_cacheZ
updated_axr
<00>axrrrr-
<00>s






zAnimation._blit_drawcCs:d
d<02>|
D<00>
}x&|D]}||kr|jj
<01>||<00>

qWdS)Nc
Ssh|]
}
|
j<00>qSr)
r/
)r*r
rrr<00>	<setcomp><3E>sz(Animation._blit_clear.<locals>.<setcomp>)r
r<>Zrestore_region)r r1
r2
r/
r
rrrr*
<00>s



zAnimation._blit_clearc
srt<00><00>_
g<00>_x<<3C>jjD]0}
|
j<05>d
<01>f
dd<03><08>
|
j<05>d<04>f
dd<03><08>
qW<00>jj<07>d<06>j	<09><02>_
<EFBFBD><00>d<00>j<0C>
dS)NZxlim_changedc

s<00>j<00>
|d<00>S)
N)r,
r
)
r3
)
r rr<00><lambda><3E><00>z'Animation._setup_blit.<locals>.<lambda>Zylim_changedc

s<00>j<00>
|d<00>S)
N)r,
r
)
r3
)
r rrr5
<00>r6
<00>resize_event)
rr,
r+
r<>r/
<00>	callbacks<6B>connectr<74>r<><00>_handle_resizer	
r)
r<>)r r3
r)
r rr
<00>s










zAnimation._setup_blitc
GsD|jj
<01>|j<03>

|j<04><05>
|j<06><07>
|<00><08>
|jj
<01>	d
|j
<EFBFBD>|_dS)Nr<4E>)r<>r<>r
r	
r<><00>stopr,
<00>clearr
r<><00>_end_redraw)r r>rrrr:
<00>s







zAnimation._handle_resizecCs>|<00>dd
<01>
|j
<01><02>
|jj<04>|j<06>

|jj<04>d|j<08>|_dS)NFr7
)	r)
r<>r
r<>r<>r
r	
r<>r:
)r Zevtrrrr=
<00>s






zAnimation._end_redrawc
	Cs
d
}t|d<02>s<>|
dkrt
d}
|
d9}
t<02><00>T}t|d<06>}tt
d}|dt
d	d
|jd<0B>}|jt|<04>
|d<0C>
t<08>	|<04>
<EFBFBD><00>
}WdQRXt|<07>
}||
kr<>t<0C>
d
||
<01>
n|<07>d<0E>
|_dj|j<11>|_t|d<02><02>
rddg}	t|d<12>r<>|jr<>|	<09>d<13>

|j|j|jd<14>|	<09>
d<15>SdSdS)a<>
        Convert the animation to an HTML5 ``<video>`` tag.

        This saves the animation as an h264 video, encoded in base64
        directly into the HTML5 video tag. This respects the rc parameters
        for the writer as well as the bitrate. This also makes use of the
        ``interval`` to control the speed, and uses the ``repeat``
        parameter to decide whether to loop.

        Parameters
        ----------
        embed_limit : float, optional
            Limit, in MB, of the returned animation. No animation is created
            if the limit is exceeded.
            Defaults to :rc:`animation.embed_limit` = 20.0.

        Returns
        -------
        video_tag : str
            An HTML5 video tag with the animation embedded as base64 encoded
            h264 video.
            If the *embed_limit* is exceeded, this returns the string
            "Video too large to embed."
        z<><video {size} {options}>
  <source type="video/mp4" src="data:video/mp4;base64,{video}">
  Your browser does not support the video tag.
</video><3E>
_base64_videoNzanimation.embed_limitiztemp.m4vzanimation.writerrSzanimation.bitrateg@<40>@)rLrMrJ)
r
z<>Animation movie is %s bytes, exceeding the limit of %s. If you're sure you want a large animation embedded, set the animation.embed_limit rc parameter to a larger value (in MB).r<>zwidth="{}" height="{}"<22>controls<6C>autoplay<61>repeatr<74><00>
 )<03>video<65>size<7A>optionszVideo too large to embed.)r
rrrr
r

r<>rxr<>r<><00>
read_bytesr<EFBFBD>rWr<>r<>r>
r1rRZ_video_sizerA
r<>r<>)
r r<>Z	VIDEO_TAG<41>tmpdirr<72><00>Writerr
Zvid64Zvid_lenrE
rrr<00>to_html5_videos:


















zAnimation.to_html5_videoTc	Cs<>|
d
krt|d<02>rd|j
}
|d
kr2|jr.dnd}t|d<06>s<>t<03><00>:}t|d<07>}t|
||d<08>}|jt|<05>
|d	<09>
|<05><08>|_	Wd
QRX|j	S)
z-Generate HTML representation of the animationNr

i<>r<>r<><00>_html_representationz	temp.html)rJr<>r<>)
r
)
r
r

rA
rrr<>r<>rx<00>	read_textrJ
)r rJr<>r<>rG
r<>r
rrr<00>	to_jshtmlQs









zAnimation.to_jshtmlc
Cs,td
}
|
dkr|<00>
<01>S|
dkr(|<00><02>SdS)z#IPython display hook for rendering.zanimation.html<6D>html5ZjshtmlN)rrI
rL
)r <00>fmtrrr<00>_repr_html_is




zAnimation._repr_html_)NF)	NNNNNNNNN)
N)NTN)r3r4r5r6r!r<>r
r<>r
r<>r
r
r
r'
r(
r)
r-
r*
r
r:
r=
rI
rL
rO
rrrrr<>xs0



B
		
O
r<>c@s2eZ
dZd
Zd
dd<06>
Zdd<08>Zd	d
<EFBFBD>Zdd<0C>ZdS)<0E>TimedAnimationa1:class:`Animation` subclass for time-based animation.

    A new frame is drawn every *interval* milliseconds.

    Parameters
    ----------
    fig : matplotlib.figure.Figure
       The figure object that is used to get draw, resize, and any
       other needed events.

    interval : number, optional
       Delay between frames in milliseconds.  Defaults to 200.

    repeat_delay : number, optional
        If the animation in repeated, adds a delay in milliseconds
        before repeating the animation.  Defaults to ``None``.

    repeat : bool, optional
        Controls whether the animation should repeat when the sequence
        of frames is completed.  Defaults to ``True``.

    blit : bool, optional
        Controls whether blitting is used to optimize drawing.  Defaults
        to ``False``.

    <20><>NTcOsL||_||_
||_|dkr,|
j<03><04>}|j|_tj||
f|<06>d
|i
|<07><02>

dS)Nr<4E>)r

<00>
_repeat_delayrA
r<>Z	new_timerr<72>r<>r!)r r8r<>Zrepeat_delayrA
r<>r>r?rrrr!<00>s






zTimedAnimation.__init__c
Gsvtj
|f
|
<01><02>}|sn|jrn|<00><03>
|<00><04>|_|jr\|j<07>|j
<01>

|j<07>	|j
<EFBFBD>

|j|j_d
Stj
|f
|
<01><02>Sn|SdS)z-
        Handler for getting events.
        TN)r<>r
rA
r
r<>r<>rR
r<>r

r
<00>_loop_delayr<79>)r r>Zstill_goingrrrr
<00>s











zTimedAnimation._stepc
Gs|j<00>
|j<02>

t<03>|<00>

dS)
N)r<>r

rS
r<>r
)r r>rrrr
<00>s
zTimedAnimation._stopc
Gs4|j<00>
|j<02>

|j|j_|j<00>|j<06>

t<07>|<00>

dS)
N)r<>r

rS
r

r<>r
r
r<>)r r>rrrrS
<00>s



zTimedAnimation._loop_delay)rQ
NTN)r3r4r5r6r!r
r
rS
rrrrrP
rs


rP
c@s0eZ
dZd
Zdd<03>Zdd<05>Zdd<07>Zdd	<09>Zd
S)<0B>ArtistAnimationaAnimation using a fixed set of `Artist` objects.

    Before creating an instance, all plotting should have taken place
    and the relevant artists saved.

    Parameters
    ----------
    fig : matplotlib.figure.Figure
       The figure object that is used to get draw, resize, and any
       other needed events.

    artists : list
        Each list entry a collection of artists that represent what
        needs to be enabled on each frame. These will be disabled for
        other frames.

    interval : number, optional
       Delay between frames in milliseconds.  Defaults to 200.

    repeat_delay : number, optional
        If the animation in repeated, adds a delay in milliseconds
        before repeating the animation.  Defaults to ``None``.

    repeat : bool, optional
        Controls whether the animation should repeat when the sequence
        of frames is completed. Defaults to ``True``.

    blit : bool, optional
        Controls whether blitting is used to optimize drawing.  Defaults
        to ``False``.

    cOs$g|_||_
tj||
f|<03>|<04>

dS)
N)r+
r&
rP
r!)r r8r1
r>r?rrrr!<00>s
zArtistAnimation.__init__c
Csrt<00>}
xN|<00>
<01>D]B}x<|D]4}|<03>d
<01>

|<03>|j<04>

|<03><05>|
kr|
<01>|<03><05><00>

qWqWx|
D]}|j<07><08>
q\WdS)NF)	r0
r<><00>set_visible<6C>set_animatedr<64>Z
get_figure<EFBFBD>addr<64>r.
)r Zfigsr<73><00>artistr8rrrr
<00>s








zArtistAnimation._init_drawcCs4|r|<00>|j
|j<02>
nx|j
D]}|<03>d
<01>

qWdS)z5
        Clears artists from the last frame.
        FN)r*
r+
r,
rU
)r r$
r
rX
rrrr'
<00>s
zArtistAnimation._pre_drawcCs"|
|_x|
D]}|<02>
d
<01>

qWdS)NT)r+
rU
)r r1
rX
rrrr(
	s

zArtistAnimation._draw_frameN)r3r4r5r6r!r
r'
r(
rrrrrT
<00>s
 
	rT
c@s@eZ
dZd
Zddd<04>
dd<06>Zdd<08>Zd	d
<EFBFBD>Zdd<0C>Zd
d<0E>ZdS)<10>
FuncAnimationa<6E>
    Makes an animation by repeatedly calling a function *func*.

    Parameters
    ----------
    fig : matplotlib.figure.Figure
       The figure object that is used to get draw, resize, and any
       other needed events.

    func : callable
       The function to call at each frame.  The first argument will
       be the next value in *frames*.   Any additional positional
       arguments can be supplied via the *fargs* parameter.

       The required signature is::

          def func(frame, *fargs) -> iterable_of_artists

       If ``blit == True``, *func* must return an iterable of all artists
       that were modified or created. This information is used by the blitting
       algorithm to determine which parts of the figure have to be updated.
       The return value is unused if ``blit == False`` and may be omitted in
       that case.

    frames : iterable, int, generator function, or None, optional
        Source of data to pass *func* and each frame of the animation

        - If an iterable, then simply use the values provided.  If the
          iterable has a length, it will override the *save_count* kwarg.

        - If an integer, then equivalent to passing ``range(frames)``

        - If a generator function, then must have the signature::

             def gen_function() -> obj

        - If *None*, then equivalent to passing ``itertools.count``.

        In all of these cases, the values in *frames* is simply passed through
        to the user-supplied *func* and thus can be of any type.

    init_func : callable, optional
       A function used to draw a clear frame. If not given, the
       results of drawing from the first item in the frames sequence
       will be used. This function will be called once before the
       first frame.

       The required signature is::

          def init_func() -> iterable_of_artists

       If ``blit == True``, *init_func* must return an iterable of artists
       to be re-drawn. This information is used by the blitting
       algorithm to determine which parts of the figure have to be updated.
       The return value is unused if ``blit == False`` and may be omitted in
       that case.

    fargs : tuple or None, optional
       Additional arguments to pass to each call to *func*.

    save_count : int, optional
       The number of values from *frames* to cache.

    interval : number, optional
       Delay between frames in milliseconds.  Defaults to 200.

    repeat_delay : number, optional
       If the animation in repeated, adds a delay in milliseconds
       before repeating the animation.  Defaults to *None*.

    repeat : bool, optional
       Controls whether the animation should repeat when the sequence
       of frames is completed.  Defaults to *True*.

    blit : bool, optional
       Controls whether blitting is used to optimize drawing. Note: when using
       blitting any animated artists will be drawn according to their zorder.
       However, they will be drawn on top of any previous artists, regardless
       of their zorder.  Defaults to *False*.

    cache_frame_data : bool, optional
       Controls whether frame data is cached. Defaults to *True*.
       Disabling cache might be helpful when frames contain large objects.
    NT)
<01>cache_frame_datac
	s<>|r||_nd
|_||_
||_||_<03>dkr6tj|_nRt<07><00>
rF<72>|_nBt<08>	<09><00>
rt<72>f
dd<03>|_t
<EFBFBD>d<04>r<>t<0B><00>
|_n<14>f
dd<03>|_<06>|_|jdkr<>d|_nt|j<03>
|_||_
g|_tj||
f|<08>

g|_dS)Nrcst<00><00>
S)
N)
r%
r)
<01>framesrrr5
<00>r6
z(FuncAnimation.__init__.<locals>.<lambda><3E>__len__cstt
<01><00>
<01>
S)
N)r%
<00>ranger)
r[
rrr5
<00>r6
<00>d)rb<00>_func<6E>
_init_funcr
<00>	itertools<6C>count<6E>	_iter_gen<65>callabler<00>iterabler
r<>r<00>_cache_frame_data<74>	_save_seqrP
r!)	r r8<00>funcr[
Z	init_funcZfargsr
rZ
r?r)
r[
rr!is.














zFuncAnimation.__init__c

Cs|<00><00>S)
N)
rc
)
r rrrr<><00>szFuncAnimation.new_frame_seqc
sV|jrt
|j<00>
|_t|j<02>
S|jdk	r8t<05>|<00><07>|j<04>S|<00><07><00><00>f
d
d<02>}
|
<01>SdS)Nc
3sHy xtd
<01>
D]}t
<01><00>
V
qWWntk
r4


YnXtjddd<04>
dS)Nr^
z2.2z<EFBFBD>FuncAnimation.save has truncated your animation to 100 frames.  In the future, no such truncation will occur; please pass 'save_count' accordingly.)
<01>message)r]
r"
r#
r
Zwarn_deprecated)
<01>
_)
r<>rr<00>gen<65>s





z.FuncAnimation.new_saved_frame_seq.<locals>.gen)rg
r-Z_old_saved_seqr%
r
ra
<00>islicer<65>)r rk
r)
r<>rr
<00>s




z!FuncAnimation.new_saved_frame_seqc
Csf|jdkr|<00>
t|<00><03><00>
<01>

n>|<00><00>|_|jr\|jdkr@td
<01>
<01>
x|jD]}
|
<01>|j<05>

qHWg|_dS)Nz7The init_func must return a sequence of Artist objects.)	r`
r(
r"
r<>r+
r<>r/rV
rg
)r r
rrrr
<00>s








zFuncAnimation._init_drawcCs<>|jr|j
<01>|
<01>

|j
|jd<00>|_
|j|
f
|j<05><02>|_|jr<>|jdkrRtd
<01>
<01>
t	|jdd<03>d<04>|_x|jD]}|<02>
|j<07>

qnWdS)Nz@The animation function must return a sequence of Artist objects.c

Ss|<00><00>S)
N)
Z
get_zorder)
rrrrr5
<00>r6
z+FuncAnimation._draw_frame.<locals>.<lambda>)
<01>key)rf
rg
r<>r
r_
rbr+
r<>r/<00>sortedrV
)r r$
r
rrrr(
<00>s






zFuncAnimation._draw_frame)NNNN)	r3r4r5r6r!r<>r
r
r(
rrrrrY
sT
1rY
)?rAr<>rC<00>iorrra
rrr<><00>pathlibr<00>platformr|rc<00>sys<79>tempfilerr<>ZnumpyrZ
matplotlibr<EFBFBD>Zmatplotlib._animation_datarrrr	r
rrr
<00>	getLoggerr3rW<00>systemrfZCREATE_NO_WINDOWr<00>objectrr
<00>ABCr7rEr<>r'r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>rP
rT
rY
rrrr<00><module>sp
















$EADo
(*





	

	"




c}RO