403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.60
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/matplotlib/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/matplotlib/__pycache__/animation.cpython-310.pyc
o

�:�a�
�@s>ddlZddlZddlZddlmZmZddlZddlZddlm	Z	ddl
Z
ddlZddlZddl
mZddlZddlZddlZddlmZddlZddlmZmZmZmZddlmZmZe�e�Z ej!dkrmd	Z"Z#ndZ"d
d�Z$Gdd
�d
�Z%e%�Z&Gdd�dej'�Z(Gdd�de(�Z)Gdd�de)�Z*e&�+d�Gdd�de(��Z,Gdd�d�Z-e&�+d�Gdd�de-e)��Z.e&�+d�Gdd�de-e*��Z/Gdd �d �Z0e&�+d!�Gd"d#�d#e0e)��Z1e&�+d$�Gd%d&�d&e0e*��Z2d'd(�Z3d)d*�Z4e&�+d+�Gd,d-�d-e*��Z5Gd.d/�d/�Z6Gd0d1�d1e6�Z7Gd2d3�d3e7�Z8Gd4d5�d5e7�Z9dS)6�N)�BytesIO�
TextIOWrapper)�Path)�TemporaryDirectory)�Image)�DISPLAY_TEMPLATE�INCLUDED_FRAMES�
JS_INCLUDE�
STYLE_INCLUDE)�_api�cbook�win32icCsPdd�}t|||�||}t|||�||}||||�||||�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.
    cSsxt||�|dkr:tt�|tj�|�|dkr"t�|tj�}|Stt�|tj�|�|dkr:t�|tj�}|S)Nr)�int�np�	nextafter�inf)�x�dpi�n�r�6/usr/lib/python3/dist-packages/matplotlib/animation.py�correct_roundoffUs �z*adjusted_figsize.<locals>.correct_roundoff)r)�w�hrrr�wnew�hnewrrr�adjusted_figsize>src@s@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�MovieWriterRegistryz<Registry of available writer classes by human readable name.cCst�|_dS�N)�dict�_registered��selfrrr�__init__eszMovieWriterRegistry.__init__cs��fdd�}|S)z�
        Decorator for registering a class under a name.

        Example use::

            @registry.register(name)
            class Foo:
                pass
        cs|�j�<|Sr)r )�
writer_cls��namer"rr�wrapperrs
z-MovieWriterRegistry.register.<locals>.wrapperr)r"r&r'rr%r�registerhs
zMovieWriterRegistry.registercCs*z
|j|}W|��StyYdSw)z�
        Check if given writer is available by name.

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

        Returns
        -------
        bool
        F)r �KeyError�isAvailable)r"r&�clsrrr�is_availablews��z MovieWriterRegistry.is_availableccs"�|jD]
}|�|�r|VqdS)z-Iterate over names of available writer class.N)r r,�r"r&rrr�__iter__�s�

��zMovieWriterRegistry.__iter__cCsg|�S)z%Get a list of available MovieWriters.rr!rrr�list��zMovieWriterRegistry.listcCs$|�|�r
|j|Std|�d���)z,Get an available writer class from its name.zRequested MovieWriter (z) not available)r,r �RuntimeErrorr-rrr�__getitem__�s

zMovieWriterRegistry.__getitem__N)
�__name__�
__module__�__qualname__�__doc__r#r(r,r.r/r2rrrrrbsrc@s`eZdZdZddd�Zejddd��Zedd	��Z	ejd
d��Z
ejdd
��Zej
dd��ZdS)�AbstractMovieWritera�
    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()`.
    �NcCsR||_|dur	|ni|_|durtjdn||_|dur$tjd|_dS||_dS)Nzanimation.codec�animation.bitrate)�fps�metadata�mpl�rcParams�codec�bitrate)r"r:r;r>r?rrrr#�s���zAbstractMovieWriter.__init__cCs&||_||_|dur|jj}||_dS)a�
        Setup for writing the movie file.

        Parameters
        ----------
        fig : `~matplotlib.figure.Figure`
            The figure object that contains the information for frames.
        outfile : str
            The filename of the resulting movie file.
        dpi : float, default: ``fig.dpi``
            The DPI (or resolution) for the file.  This controls the size
            in pixels of the resulting movie file.
        N)�outfile�figr�r"rAr@rrrr�setup�s

zAbstractMovieWriter.setupcCs*|j��\}}t||j�t||j�fS)z7A tuple ``(width, height)`` in pixels of a movie frame.)rA�get_size_inchesrr)r"rrrrr�
frame_size�szAbstractMovieWriter.frame_sizecK�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
        `~.Figure.savefig` call that saves the figure.
        Nr�r"�savefig_kwargsrrr�
grab_frame��zAbstractMovieWriter.grab_framecCrF)�,Finish any processing for writing the movie.Nrr!rrr�finish�rJzAbstractMovieWriter.finishcos>�|j|||g|�Ri|��z
|VW|��dS|��w)z�
        Context manager to facilitate writing the movie file.

        ``*args, **kw`` are any parameters that should be passed to `setup`.
        N)rCrL)r"rAr@r�args�kwargsrrr�saving�s
�zAbstractMovieWriter.saving)r8NNNr)r3r4r5r6r#�abc�abstractmethodrC�propertyrErIrL�
contextlib�contextmanagerrOrrrrr7�s



r7cs�eZdZdZdgZ		d�fdd�	Zdd�Zd�fd	d
�	Zdd�Z�fd
d�Z	dd�Z
dd�Zdd�Ze
�d�dd��Zedd��Zedd��Z�ZS)�MovieWritera�
    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.
    �rgbar8Ncs>t|�tur
td��t�j||||d�|jd|_||_dS)a�
        Parameters
        ----------
        fps : int, default: 5
            Movie frame rate (per second).
        codec : str or None, default: :rc:`animation.codec`
            The codec to use.
        bitrate : int, default: :rc:`animation.bitrate`
            The bitrate of the movie, in kilobits per second.  Higher values
            means higher quality movies, but increase the file size.  A value
            of -1 lets the underlying movie encoder select the bitrate.
        extra_args : list of str or None, optional
            Extra command-line arguments passed to the underlying movie
            encoder.  The default, None, means to use
            :rc:`animation.[name-of-encoder]_args` for the builtin writers.
        metadata : dict[str, str], default: {}
            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.)r:r;r>r?rN)�typerU�	TypeError�superr#�supported_formats�frame_format�
extra_args)r"r:r>r?r\r;��	__class__rrr#s��
zMovieWriter.__init__cCs�|jdkr1|j��\}}t|||jd�\}}||f||fkr0|jj||dd�t�d||||�n|j��\}}tjdg|j	�R�||fS)N�h264�T)�forwardz?figure size in inches has been adjusted from %s x %s to %s x %szframe size in pixels is %s x %s)
r>rArDrr�set_size_inches�_log�info�debugrE)r"�wo�horrrrr�_adjust_frame_size0s
��zMovieWriter._adjust_frame_sizecs.t�j|||d�|��\|_|_|��dS�N)r)rYrCrh�_w�_h�_runrBr]rrrC=szMovieWriter.setupcCs:|��}t�dt�|��tj}tj||||td�|_	dS)Nz%MovieWriter._run: running command: %s)�stdin�stdout�stderr�
creationflags)
�_argsrcrdr�_pformat_subprocess�
subprocess�PIPE�Popen�subprocess_creation_flags�_proc)r"�commandrtrrrrlEs��zMovieWriter._runcs2tj�j|ddd�}|dur|�dS|��dS)rK�3.4zfinish())�since�alternativeN)r�deprecate_method_override�cleanup�_cleanup)r"�overridden_cleanupr]rrrLQs
�
zMovieWriter.finishcKsBt�d�|j�|j|j�|jj|jjf|j	|j
d�|��dS)Nz'MovieWriter.grab_frame: Grabbing frame.��formatr)rcrerArbrjrk�savefigrwrmr[rrGrrrrIZs
�
�zMovieWriter.grab_framecCstd�S)z9Assemble list of encoder-specific command-line arguments.z)args needs to be implemented by subclass.��NotImplementedErrorr!rrrrqdr0zMovieWriter._argscCs�|j��\}}tt|����}tt|����}|r(t�|jjr"tj	ntj
d|�|r9t�|jjr3tj	ntj
d|�|jjrIt�|jj|jj
||��dS)z>Clean-up and collect the process used to write the movie file.zMovieWriter stdout:
%szMovieWriter stderr:
%sN)rw�communicaterr�readrc�log�
returncode�logging�WARNING�DEBUGrs�CalledProcessErrorrM)r"�out�errrrrr~hs$����zMovieWriter._cleanuprycCs|��dSr)r~r!rrrr}zszMovieWriter.cleanupcCsttj|j�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.
        )�strr<r=�	_exec_key�r+rrr�bin_path~szMovieWriter.bin_pathcCst�|���duS)z<Return whether a MovieWriter subclass is actually available.N)�shutil�whichr�r�rrrr*��zMovieWriter.isAvailable)r8NNNNr)r3r4r5r6rZr#rhrCrlrLrIrqr~r�
deprecatedr}�classmethodr�r*�
__classcell__rrr]rrU�s&�$
	


rUcsteZdZdZ�fdd�Zddd�Zdd�Zed	d
��Zej	dd
��Zdd
�Z
dd�Z�fdd�Z�fdd�Z
�ZS)�FileMovieWriterz}
    `MovieWriter` for writing to individual files and stitching at the end.

    This must be sub-classed to be useful.
    cs"t�j|i|��tjd|_dS)Nzanimation.frame_format)rYr#r<r=r[)r"rMrNr]rrr#�szFileMovieWriter.__init__NcCst||_||_|dur|jj}||_|��|dur(t�|_tt|jjd��|_	nd|_||_	d|_
t�|_d|_
dS)a�
        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 : float, default: ``fig.dpi``
            The dpi of the output file. This, with the figure size,
            controls the size in pixels of the resulting movie file.
        frame_prefix : str, optional
            The filename prefix to use for temporary files.  If *None* (the
            default), files are written to a temporary directory which is
            deleted by `cleanup`; if not *None*, no temporary files are
            deleted.
        N�tmprz
%s%%07d.%s)rAr@rrhr�_tmpdirr�rr&�temp_prefix�_frame_counterr/�_temp_paths�fname_format_str)r"rAr@r�frame_prefixrrrrC�s
zFileMovieWriter.setupcCs|jr
|j��dSdSr)r�r}r!rrr�__del__�s�zFileMovieWriter.__del__cCs|jS)z�
        Format (png, jpeg, etc.) to use for saving the frames, which can be
        decided by the individual subclasses.
        )�
_frame_formatr!rrrr[�szFileMovieWriter.frame_formatc	CsN||jvr
||_dSt�d|�dt|�j�d|jd�d��|jd|_dS)NzIgnoring file format z which is not supported by z; using rz	 instead.)rZr�r�
warn_externalrWr3)r"r[rrrr[�s

���cCs|j|j|jfSr)r�r�r[r!rrr�_base_temp_name�r�zFileMovieWriter._base_temp_namecKs�t|��|j�}|j�|�|jd7_t�d|j|�t|d��}|jj	|f|j
|jd�|��Wd�dS1s>wYdS)N�z8FileMovieWriter.grab_frame: Grabbing frame %d to path=%s�wbr�)rr�r�r��appendrcre�openrAr�r[r)r"rH�path�sinkrrrrI�s��"�zFileMovieWriter.grab_framecs|��t���dSr)rlrYrLr!r]rrrL�szFileMovieWriter.finishcs0t���|jrt�d|j�|j��dSdS)N�'MovieWriter: clearing temporary path=%s)rYr~r�rcrer}r!r]rrr~�s

�zFileMovieWriter._cleanup)NN)r3r4r5r6r#rCr�rRr[�setterr�rIrLr~r�rrr]rr��s
$


r��pillowcs:eZdZedd��Zd
�fdd�	Zdd�Zdd	�Z�ZS)�PillowWritercCrF�NTrr�rrrr*��zPillowWriter.isAvailableNcst�j|||d�g|_dSri)rYrC�_framesrBr]rrrC�s
zPillowWriter.setupcKsRt�}|jj|fii|�d|jd����|j�t�d|j|�	�dddd��dS)NrVr��RGBA�rawrr�)
rrAr�rr�r�r�
frombufferrE�	getbuffer)r"rH�bufrrrrI�s��

�zPillowWriter.grab_framecCs4|jdj|jd|jdd�td|j�dd�dS)NrTr���)�save_all�
append_images�duration�loop)r��saver@rr:r!rrrrLs

�zPillowWriter.finishr)	r3r4r5r�r*rCrIrLr�rrr]rr��s
r�c@s$eZdZdZdZdZedd��ZdS)�
FFMpegBasez�
    Mixin class for FFMpeg output.

    To be useful this must be multiply-inherited from with a
    `MovieWriterBase` sub-class.
    zanimation.ffmpeg_pathzanimation.ffmpeg_argscCs�g}t|j�jdkrd|_n|�d|jg�|jdur|jntj|j}|jdkr5d|vr5|�ddg�n|jdkrEd|vrE|�ddg�|j	d	krT|�d
d|j	g�|�|�|j
��D]\}}|�dd
||fg�q^|d|jgS)Nz.gif�gif�-vcodecr_�-pix_fmt�yuv420pz-filter_complexz1split [a][b];[a] palettegen [p];[b][p] paletteuserz-bz%dkz	-metadataz%s=%sz-y)rr@�suffixr>�extendr\r<r=�	_args_keyr?r;�items)r"rMr\�k�vrrr�output_argss&
��

zFFMpegBase.output_argsN)r3r4r5r6r�r�rRr�rrrrr�	sr��ffmpegc@�eZdZdZdd�ZdS)�FFMpegWriterz|
    Pipe-based ffmpeg writer.

    Frames are streamed directly to ffmpeg via a pipe and written in a single
    pass.
    cCs\|��dddddd|jd|jdt|j�g}t��tjkr#|dd	g7}|d
dg|j	7}|S)N�-f�rawvideor�z-s�%dx%dr��-r�	-loglevel�error�-izpipe:)
r�rEr[r�r:rc�getEffectiveLevelr�r�r��r"rMrrrrq:s
�zFFMpegWriter._argsN�r3r4r5r6rqrrrrr�2sr��ffmpeg_filec@� eZdZdZgd�Zdd�ZdS)�FFMpegFileWriterz�
    File-based ffmpeg writer.

    Frames are written to temporary files on disk and then stitched
    together at the end.
    ��png�jpeg�tiffr�rVcCs�g}|jdvr|dddddd|jdd	d
t|j�g
7}|dt|j�d|��d
t|j�g7}t��tj	kr:|ddg7}|�
�g|�|j�S)N>r�rVr��image2r�r�z-video_sizer�z
-pixel_formatrVz
-framerater�r�z-vframesr�r�)r[rEr�r:r�r�rcr�r�r�r�r�r�rrrrqTs


�
�zFFMpegFileWriter._argsN�r3r4r5r6rZrqrrrrr�Jsr�csTeZdZdZdZdZedd��Zedd��Ze	�fdd	��Z
e	�fd
d��Z�ZS)�ImageMagickBasez�
    Mixin class for ImageMagick output.

    To be useful this must be multiply-inherited from with a
    `MovieWriterBase` sub-class.
    zanimation.convert_pathzanimation.convert_argscCs
d|jS)NgY@)r:r!rrr�delayvs
zImageMagickBase.delaycCs*|jdur|jntj|j}g|�|j�Sr)r\r<r=r�r@)r"r\rrrr�zs
�zImageMagickBase.output_argscs"t���}|dkrt�d�j}|S)N�convert�magick)rYr�r<�_get_executable_info�
executable)r+�binpathr]rrr��s
zImageMagickBase.bin_pathc
sBzt���WStjy }z
t�d|�WYd}~dSd}~ww)Nz"ImageMagick unavailable due to: %sF)rYr*r<�ExecutableNotFoundErrorrcre)r+�_enfr]rrr*�s��zImageMagickBase.isAvailable)
r3r4r5r6r�r�rRr�r�r�r�r*r�rrr]rr�ks

r��imagemagickc@r�)�ImageMagickWriterz�
    Pipe-based animated gif.

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

    cCs4|��dd|jdddt|j�ddd|jg
|jS)	N�-size�%ix%i�-depth�8�-delay�-loop�0z%s:-)r�rEr�r�r[r�r!rrrrq�s��zImageMagickWriter._argsNr�rrrrr��sr��imagemagick_filec@r�)�ImageMagickFileWriterz�
    File-based animated gif writer.

    Frames are written to temporary files on disk and then stitched
    together at the end.
    r�c
CsN|jdkrdnd}|��dd|jdddt|j�d	d
d||j|jfg
|jS)Nr�zrgba:�r�r�r�r�r�r�r�z%s%s*.%s)r[r�rEr�r�r�r��r"�fmtrrrrq�s��zImageMagickFileWriter._argsNr�rrrrr��sr�cCstjt|�|dj|d�S)zpaths should be a list of Pathsr)�Nframes�	frame_dirr[)rr��len�parent)�pathsr[rrr�_included_frames�s
�r�cs2�dkrd�d�dd���fdd�t|�D��S)z7frame_list should be a list of base64-encoded png files�svgzsvg+xmlz,  frames[{0}] = "data:image/{1};base64,{2}"
�
r�c	3s*�|]\}}��|�|�dd��VqdS)r�z\
N)r��replace)�.0�i�
frame_data�r[�templaterr�	<genexpr>�s
��
�z#_embedded_frames.<locals>.<genexpr>)�join�	enumerate)�
frame_listr[rrr�_embedded_frames�s
�r�htmlcs^eZdZdZgd�Zedd��Z			d�fd	d
�	Zd�fdd�	Z�fd
d�Z	dd�Z
�ZS)�
HTMLWriterz(Writer for JavaScript-based HTML movies.)r�r�r�r�cCrFr�rr�rrrr*�r�zHTMLWriter.isAvailable�NFr�c		sx|rt�d�d}||_|��|_tjgd�|jd�|dur&tjd|_	n||_	|j	d9_	t
��|||||�dS)NzHTMLWriter ignores 'extra_args'r)r��once�reflect)�default_mode�animation.embed_limit�)rc�warning�embed_frames�lowerrr�
check_in_listr<r=�_bytes_limitrYr#)	r"r:r>r?r\r;rr�embed_limitr]rrr#�s


�zHTMLWriter.__init__cs�t|�}tjddg|jd�g|_d|_d|_|js2|dur&|�|j	d�}|j
ddd�|d	}nd}t��||||�d|_
dS)
Nz.htmlz.htm)�outfile_extensionrFr�T)�parents�exist_ok�frame)rrrr��
_saved_frames�_total_bytes�
_hit_limitr�	with_name�stem�mkdirrYrC�_clear_temp)r"rAr@rr�r�r]rrrC�s

zHTMLWriter.setupcs�|jrI|jrdSt�}|jj|f|j|jd�|��t�|�	���
d�}|jt|�7_|j|j
krAt�d|j|j
�d|_dS|j�|�dSt�jdi|��S)Nr��asciiz�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.Tr)rrrrAr�r[r�base64�encodebytes�getvalue�decoderr�rrcrrr�rYrI)r"rH�f�	imgdata64r]rrrIs&���
zHTMLWriter.grab_framec
Cs�|jrt|j|j�}t|j�}nt|j|j�}t|j�}tdddd�}d||jd<d|j	}t
|jd��"}|�t
t�|�tjd	t��j|||d�|���Wd�n1sZwY|jrpt�d|j�|j��dSdS)
Nr�)�once_checked�loop_checked�reflect_checked�checked�_checkedr�r)�idr��fill_frames�intervalr�r)rrrr[r�r�r�rrr:r�r@�writer	r
rr��uuid�uuid4�hexr�rcrer})r"r/r��	mode_dictr0�ofrrrrLs6�
�
�
���zHTMLWriter.finish)rNNNNFr�Nr)r3r4r5r6rZr�r*r#rCrIrLr�rrr]rr
�s
�r
c@s�eZdZdZd4dd�Zdd�Zdd	�Zd
d�Z			d5dd�d
d�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd6d)d*�Zd7d,d-�Zd.d/�Zd0d1�Zd2d3�ZdS)8�	Animationa�
    A base class for Animations.

    This class is not usable as is, and should be subclassed to provide needed
    behavior.

    .. note::

        You must store the created Animation in a variable that lives as long
        as the animation should run. Otherwise, the Animation object will be
        garbage-collected and the animation stops.

    Parameters
    ----------
    fig : `~matplotlib.figure.Figure`
        The figure object used to get needed events, such as draw or resize.

    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 `TimedAnimation`) and file
        system notifications.

    blit : bool, default: False
        Whether blitting is used to optimize drawing.

    See Also
    --------
    FuncAnimation,  ArtistAnimation
    NFcCsfd|_||_|o|jj|_|��|_||_|j�d|j	�|_
|jj�d|j�|_|jr1|�
�dSdS)NF�
draw_event�close_event)�_draw_was_started�_fig�canvas�
supports_blit�_blit�
new_frame_seq�	frame_seq�event_source�mpl_connect�_start�_first_draw_id�_stop�	_close_id�_setup_blit)r"rArA�blitrrrr#\s

��zAnimation.__init__cCst|dd�s
t�d�dSdS)Nr:Tz�Animation was deleted without rendering anything. This is most likely not intended. To prevent deletion, assign the Animation to a variable, e.g. `anim`, that exists until you have outputted the Animation using `plt.show()` or `anim.save()`.)�getattr�warnings�warnr!rrrr�ws
��zAnimation.__del__cGsD|jj��rdS|jj�|j�|��|j�|j�|j�	�dS)z�
        Starts interactive animation. Adds the draw frame command to the GUI
        handler, calls show to start the event loop.
        N)
r;r<�	is_saving�mpl_disconnectrD�
_init_drawrA�add_callback�_step�startr�rrrrC�szAnimation._startcGs>|jr|jj�|j�|jj�|j�|j�|j�d|_dSr)	r>r;r<rM�
_resize_idrFrA�remove_callbackrPr�rrrrE�s

zAnimation._stop)�progress_callbackc
s�|dur
tjd}nt|t�s!tdd�|||||fD��r!td��|
dur'i}
|dur5t�d�r5d�j}|dur>tjd}|d	krF�jj	}i}|durP||d
<|durX||d<|dur`||d<|durh||d
<�g}
|	dur{|
�
�fdd�|	D��t|t�r�zt|}Wnty�t}t
�d|�Ynw||fi|��}t
�dt|��d|
vr�t
�d�|
�d�tjddkr�t
�d�t�ddi���|��j||��utj�jjddd��Z|
D]}|��q�d}dd�|
D�}d|vr�d}nt|�}tdd�|
D��D]+}t|
|�D]\}}|j|dd�|du�r$|||�|d7}�q|jdi|
���qWd�n	1�s;wYWd�n1�sKwYWd�dSWd�dS1�sdwYdS) a�
        Save the animation as a movie file by drawing every frame.

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

        writer : `MovieWriter` or str, default: :rc:`animation.writer`
            A `MovieWriter` instance to use or a key that identifies a
            class to use, such as 'ffmpeg'.

        fps : int, optional
            Movie frame rate (per second).  If not set, the frame rate from the
            animation's frame interval.

        dpi : float, default: :rc:`savefig.dpi`
            Controls the dots per inch for the movie frames.  Together with
            the figure's size in inches, this controls the size of the movie.

        codec : str, default: :rc:`animation.codec`.
            The video codec to use.  Not all codecs are supported by a given
            `MovieWriter`.

        bitrate : int, default: :rc:`animation.bitrate`
            The bitrate of the movie, in kilobits per second.  Higher values
            means higher quality movies, but increase the file size.  A value
            of -1 lets the underlying movie encoder select the bitrate.

        extra_args : list of str or None, optional
            Extra command-line arguments passed to the underlying movie
            encoder.  The default, None, means to use
            :rc:`animation.[name-of-encoder]_args` for the builtin writers.

        metadata : dict[str, str], default: {}
            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, default: []
            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, default: {}
            Keyword arguments passed to each `~.Figure.savefig` call used 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.
        N�animation.writercss�|]}|duVqdSrr)r��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.�	_interval�@�@zsavefig.dpi�figurer>r?r\r;c3s �|]}|j�jur|VqdSr)r;)r��animr!rrrs���z1MovieWriter %s unavailable; using Pillow instead.zAnimation.save using %s�bbox_inchesz�Warning: discarding the 'bbox_inches' argument in 'savefig_kwargs' as it may cause frame size to vary, which is inappropriate for animation.zsavefig.bbox�tightzkDisabling savefig.bbox = 'tight', as it may cause frame size to vary, which is inappropriate for animation.T)�
_is_saving�managerrcSsg|]}t|dd��qS)�
save_countN)rI�r��arrr�
<listcomp>:s�z"Animation.save.<locals>.<listcomp>cSsg|]}|���qSr)�new_saved_frame_seqr`rrrrb@sF)rHr�r)r<r=�
isinstancer��anyr1�hasattrrWr;rr��writersr�rcrrdrW�pop�
rc_contextrOr�_setattr_cmr<rN�sum�zip�_draw_next_framerI)r"�filename�writerr:rr>r?r\r;�
extra_animrHrT�
writer_kwargs�all_animr$rZ�frame_number�save_count_list�total_frames�data�drr!rr��s�M
��

�
��


�
��
�

����TzAnimation.savecGs4zt|j�}|�||j�WdStyYdSw)z�
        Handler for getting events. By default, gets the next frame in the
        sequence and hands the data off to be drawn.
        TF)�nextr@rmr>�
StopIteration)r"rM�	framedatarrrrPIs
�zAnimation._stepcCs
t|j�S)z+Return a new sequence of frame information.)�iter�
_framedatar!rrrr?X�
zAnimation.new_frame_seqcC�|��S)z8Return a new sequence of saved/cached frame information.)r?r!rrrrc]szAnimation.new_saved_frame_seqcCs&|�||�|�|�|�||�dSr)�	_pre_draw�_draw_frame�
_post_draw�r"rzrHrrrrmbs
zAnimation._draw_next_framecCs
d|_dSr�)r:r!rrrrNir}zAnimation._init_drawcCs|r
|�|j�dSdSr)�_blit_clear�_drawn_artistsr�rrrrns�zAnimation._pre_drawcCstd��)NzDNeeds to be implemented by subclasses to actually make an animation.r�)r"rzrrrr�tr0zAnimation._draw_framecCs*|r
|jr
|�|j�dS|jj��dSr)r��
_blit_drawr;r<�	draw_idler�rrrr�ys
zAnimation._post_drawcCs�dd�|D�}|D]#}|��}|j�|t�df�\}}||kr,||jj�|j�f|j|<q	|D]}|j�	|�q/|D]
}|jj�
|j�q:dS)NcS�h|]}|j�qSr��axesr`rrr�	<setcomp>��z'Animation._blit_draw.<locals>.<setcomp>)�	_get_view�_blit_cache�get�objectrYr<�copy_from_bbox�bboxr��draw_artistrH)r"�artists�
updated_ax�ax�cur_view�view�bgrarrrr��s
���zAnimation._blit_drawc	Csjdd�|D�}|D])}z	|j|\}}Wn	tyYq	w|��|kr,|jj�|�q	|j�|�q	dS)NcSr�rr�r`rrrr��r�z(Animation._blit_clear.<locals>.<setcomp>)r�r)r�rYr<�restore_regionrh)r"r�r�r�r�r�rrrr��s��zAnimation._blit_clearcCs4t�|_g|_|jj�d|j�|_|�d|j	�dS)N�resize_event)
rr�r�r;r<rB�
_on_resizerRr�r>r!rrrrG�s
�zAnimation._setup_blitcCsD|jj�|j�|j��|j��|��|jj�	d|j
�|_dS)Nr8)r;r<rMrRrA�stopr��clearrNrB�_end_redraw�r"�eventrrrr��s



�zAnimation._on_resizecCs>|�dd�|j��|jj�|j�|jj�d|j�|_dS)NFr�)	r�rArQr;r<rMrRrBr�r�rrrr��s


�zAnimation._end_redrawc
Cs$d}t|d�sm|durtjd}|d9}t��1}t|d�}ttjd}|dtjd	d
|jd�}|jt|�|d�t	�
|���}Wd�n1sKwYt|�}||kr`t
�d
||�n
|�d�|_dj|j�|_t|d�r�ddg}	t|d�r�|jr�|	�d�|j|j|jd�|	�d�SdS)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 :rc:`animation.writer`
        and :rc:`animation.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
        -------
        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>�
_base64_videoNrrztemp.m4vrUr_r9rX)r>r?r:�roz�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="{}"�controls�autoplay�repeatr�� )�video�size�optionszVideo too large to embed.)rfr<r=rrrgrWr�r�r#r$�
read_bytesr�rcrr&r�r�rE�_video_sizer�r�r)
r"r�	VIDEO_TAG�tmpdirr��Writerro�vid64�vid_lenr�rrr�to_html5_video�sD


����

�zAnimation.to_html5_videoTcCs�|durt|d�rd|j}|dur|jrdnd}t|d�sMt��$}t|d�}t|||d�}|jt|�|d	�|��|_	Wd�|j	S1sHwY|j	S)
a
        Generate HTML representation of the animation.

        Parameters
        ----------
        fps : int, optional
            Movie frame rate (per second). If not set, the frame rate from
            the animation's frame interval.
        embed_frames : bool, optional
        default_mode : str, optional
            What to do when the animation ends. Must be one of ``{'loop',
            'once', 'reflect'}``. Defaults to ``'loop'`` if ``self.repeat``
            is True, otherwise ``'once'``.
        NrWr�r�r�_html_representationz	temp.html)r:rrr�)
rfrWr�rrr
r�r��	read_textr�)r"r:rrr�r�rorrr�	to_jshtmls"


�
��zAnimation.to_jshtmlcCs.tjd}|dkr
|��S|dkr|��SdS)z#IPython display hook for rendering.zanimation.html�html5�jshtmlN)r<r=r�r�r�rrr�_repr_html_:s
�zAnimation._repr_html_cC�.|j��|jr|jD]	}|�d�qdSdS)zPause the animation.FN)rAr�r>r��set_animated�r"�artistrrr�pauseB�

�zAnimation.pausecCr�)zResume the animation.TN)rArQr>r�r�r�rrr�resumeIr�zAnimation.resume�NF)	NNNNNNNNNr)NTN)r3r4r5r6r#r�rCrEr�rPr?rcrmrNrr�r�r�r�rGr�r�r�r�r�r�r�rrrrr7;s>
 
��.
	
	
O%r7cs2eZdZdZ		d
�fdd�	Z�fdd	�Z�ZS)�TimedAnimationa}
    `Animation` subclass for time-based animation.

    A new frame is drawn every *interval* milliseconds.

    .. note::

        You must store the created Animation in a variable that lives as long
        as the animation should run. Otherwise, the Animation object will be
        garbage-collected and the animation stops.

    Parameters
    ----------
    fig : `~matplotlib.figure.Figure`
        The figure object used to get needed events, such as draw or resize.
    interval : int, default: 200
        Delay between frames in milliseconds.
    repeat_delay : int, default: 0
        The delay in milliseconds between consecutive animation runs, if
        *repeat* is True.
    repeat : bool, default: True
        Whether the animation repeats when the sequence of frames is completed.
    blit : bool, default: False
        Whether blitting is used to optimize drawing.
    ��rTNcsX||_|dur	|nd|_||_|dur|jj|jd�}t�j|g|�Rd|i|��dS)Nr)r0rA)rW�
_repeat_delayr�r<�	new_timerrYr#)r"rAr0�repeat_delayr�rArMrNr]rrr#ls"zTimedAnimation.__init__csDt�j|�}|s|jr|��|��|_|j|j_dS|j	|j_|S)zHandler for getting events.T)
rYrPr�rNr?r@r�rAr0rW)r"rM�still_goingr]rrrPxs



zTimedAnimation._step)r�rTN)r3r4r5r6r#rPr�rrr]rr�Qs�r�cs<eZdZdZ�fdd�Z�fdd�Zdd�Zdd	�Z�ZS)
�ArtistAnimationa_
    Animation using a fixed set of `.Artist` objects.

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

    .. note::

        You must store the created Animation in a variable that lives as long
        as the animation should run. Otherwise, the Animation object will be
        garbage-collected and the animation stops.

    Parameters
    ----------
    fig : `~matplotlib.figure.Figure`
        The figure object used to get needed events, such as draw or resize.
    artists : list
        Each list entry is a collection of `.Artist` objects that are made
        visible on the corresponding frame.  Other artists are made invisible.
    interval : int, default: 200
        Delay between frames in milliseconds.
    repeat_delay : int, default: 0
        The delay in milliseconds between consecutive animation runs, if
        *repeat* is True.
    repeat : bool, default: True
        Whether the animation repeats when the sequence of frames is completed.
    blit : bool, default: False
        Whether blitting is used to optimize drawing.
    cs*g|_||_t�j|g|�Ri|��dSr)r�r|rYr#)r"rAr�rMrNr]rrr#�szArtistAnimation.__init__cspt���t�}|��D]}|D]}|�d�|�|j�|��|vr*|�|���qq|D]}|j	�
�q.dSr�)rYrN�setr?�set_visibler�r>�
get_figure�addr<r�)r"�figsr'r�rAr]rrrN�s

���zArtistAnimation._init_drawcCs.|r
|�|j�dS|jD]}|�d�q
dS)z#Clears artists from the last frame.FN)r�r�r�)r"rzrHr�rrrr�s

�zArtistAnimation._pre_drawcCs||_|D]}|�d�qdSr�)r�r�)r"r�r�rrrr��s�zArtistAnimation._draw_frame)	r3r4r5r6r#rNrr�r�rrr]rr��s	
r�csPeZdZdZ		ddd��fdd�Zdd�Zd	d
�Z�fdd�Zd
d�Z�Z	S)�
FuncAnimationa�

    Makes an animation by repeatedly calling a function *func*.

    .. note::

        You must store the created Animation in a variable that lives as long
        as the animation should run. Otherwise, the Animation object will be
        garbage-collected and the animation stops.

    Parameters
    ----------
    fig : `~matplotlib.figure.Figure`
        The figure object used to get needed events, such as draw or resize.

    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, default: 100
        Fallback for the number of values from *frames* to cache. This is
        only used if the number of frames cannot be inferred from *frames*,
        i.e. when it's an iterator without length or a generator.

    interval : int, default: 200
        Delay between frames in milliseconds.

    repeat_delay : int, default: 0
        The delay in milliseconds between consecutive animation runs, if
        *repeat* is True.

    repeat : bool, default: True
        Whether the animation repeats when the sequence of frames is completed.

    blit : bool, default: False
        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.

    cache_frame_data : bool, default: True
        Whether frame data is cached.  Disabling cache might be helpful when
        frames contain large objects.
    NT)�cache_frame_datac
s�|r|�_nd�_|�_|�_|�_�durtj�_n>t��r#��_n6t�	��rO|�
dd�r=��_�f�fdd�	}	|	�_n�fdd��_t�d�rNt
���_n
�fd	d��_��_�jdurbd
�_nt�j��_|�_g�_t�j|fi|��g�_dS)Nrr�Tc3s$�t��jd�\}�_|EdHdS)Nr`)�	itertools�tee�	_tee_from)�frames�thisr!rr�iter_framesJs�z+FuncAnimation.__init__.<locals>.iter_framescst��Sr)r{r�r�rr�<lambda>O�z(FuncAnimation.__init__.<locals>.<lambda>�__len__cstt���Sr)r{�rangerr�rrr�Ss�d)rq�_func�
_init_funcr_r��count�	_iter_gen�callabler�iterabler�r�rfr�r�_cache_frame_data�	_save_seqrYr#)
r"rA�funcr��	init_func�fargsr_r�rNr�r])r�r"rr#1s8



�

zFuncAnimation.__init__cCr~r)r�r!rrrr?jr0zFuncAnimation.new_frame_seqcsR|jrt|j�|_t|j�S|jdurt�|��|j�S|����fdd�}|�S)Nc3sF�ztd�D]}t��VqWn
tyYdSwtjddd�dS)Nr�z2.2z�FuncAnimation.save has truncated your animation to 100 frames.  In the future, no such truncation will occur; please pass 'save_count' accordingly.)�message)r�rxryr�warn_deprecated)�_�r@rr�gen~s���
�z.FuncAnimation.new_saved_frame_seq.<locals>.gen)r�r/�_old_saved_seqr{r_r��islicer?)r"r�rr�rrcns


z!FuncAnimation.new_saved_frame_seqcs�t���|jdur(zt|���}Wnty!t�d�YdSw|�|�n|��|_	|j
rE|j	dur9td��|j	D]}|�|j
�q<g|_
dS)Nz�Can not start iterating the frames for the initial draw. This can be caused by passing in a 0 length sequence for *frames*.

If you passed *frames* as a generator it may be exhausted due to a previous display or save.z7The init_func must return a sequence of Artist objects.)rYrNr�rxr?ryrJrKr�r�r>r1r�r�)r"rrar]rrrN�s$

��



zFuncAnimation._init_drawcCs�|jr	|j�|�|j|jd�|_|j|g|j�R�|_|jr\td�}zt	|j�Wn
t
y6|d�w|jD]}t|tj
j�sE|�q:t|jdd�d�|_|jD]
}|�|j�qSdSdS)Nz@The animation function must return a sequence of Artist objects.cSr~r)�
get_zorder)rrrrr��r�z+FuncAnimation._draw_frame.<locals>.<lambda>)�key)r�r�r�r_r�rqr�r>r1r{rXrdr<r��Artist�sortedr�)r"rzr�rrarrrr��s,�
��
�zFuncAnimation._draw_frame)NNNN)
r3r4r5r6r#r?rcrNr�r�rrr]rr��sY��9 r�):rPr#rS�iorrr�r��pathlibrr�rs�sys�tempfilerr2rJ�numpyr�PILr�
matplotlibr<�matplotlib._animation_datarrr	r
rr�	getLoggerr3rc�platformrv�CREATE_NO_WINDOWrrrg�ABCr7rUr�r(r�r�r�r�r�r�r�r�rr
r7r�r�r�rrrr�<module>sj



$8Tc) 'm:L

Youez - 2016 - github.com/yon3zu
LinuXploit