hSrSSKJr SSKJrJrJr SSKJrJ r SSK r SSK r SSK r SSK r SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKJr SSKrSSKrSSKJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r' SSK(J)r) SS K*J+r+ SS K,J-r- SS K.J/r/ SS K0J1r1 SS K2J3r3 SSK4J5r5 SSK6J7r7J8r8 \Rr"\:5r;SSSSSSSSSSSSSSS.rS!r?"S"S#5r@"S$S%5rA"S&S'5rB"S(S)5rC"S*S+\C5rD"S,S-\C5rE"S.S/\C5rF"S0S1\C5rG"S2S3\ 5rH"S4S5\G5rI"S6S7\C5rJ"S8S9\G5rKS:rLS;rMSRS<jrNS=rOS>rP\S?5rQ"S@SA5rRSSSBjrSSSSCjrT"SDSE\U5rV"SFSG5rW\RrX"SHSI\Y\5rZ"SJSK5r["SLSM5r\"SNSO5r]"SPSQ\]5r^g)Ta Abstract base classes define the primitives that renderers and graphics contexts must implement to serve as a Matplotlib backend. `RendererBase` An abstract base class to handle drawing/rendering operations. `FigureCanvasBase` The abstraction layer that separates the `.Figure` from the backend specific details like a user interface drawing area. `GraphicsContextBase` An abstract base class that provides color, line styles, etc. `Event` The base class for all of the Matplotlib event handling. Derived classes such as `KeyEvent` and `MouseEvent` store the meta data like keys and buttons pressed, x and y locations in pixel and `~.axes.Axes` coordinates. `ShowBase` The base class for the ``Show`` class of each interactive backend; the 'show' callable is then set to ``Show.__call__``. `ToolContainerBase` The base class for the Toolbar class of each interactive backend. ) namedtuple) ExitStackcontextmanager nullcontext)EnumIntEnumN)WeakKeyDictionary) _api backend_toolscbookcolors _docstringtext _tight_bbox transformswidgetsis_interactivercParams)Gcf) ToolManager) _setattr_cm)ConstrainedLayoutEngine)Path) TexManager)Affine2D) JoinStyleCapStylezEncapsulated Postscriptz Joint Photographic Experts GroupzPortable Document FormatzPGF code for LaTeXzPortable Network Graphics PostscriptzRaw RGBA bitmapzScalable Vector GraphicszTagged Image File FormatzWebP Image Format)epsjpgjpegpdfpgfpngpsrawrgbasvgsvgztiftiffwebpzmatplotlib.backends.backend_pszmatplotlib.backends.backend_aggzmatplotlib.backends.backend_pdfzmatplotlib.backends.backend_pgfzmatplotlib.backends.backend_svgc2UcSnU[U'U[U'g)z Register a backend for saving to a given file format. Parameters ---------- format : str File extension backend : module string or canvas class Backend for handling file output description : str, default: "" Description of the file type. N)_default_backends_default_filetypes)formatbackend descriptions J/var/www/html/env/lib/python3.13/site-packages/matplotlib/backend_bases.pyregister_backendr5as% 'f!,vcU[;ag[Un[U[5(a)[R"U5R nU[U'U$)zj Return the registered default canvas for given file format. Handles deferred import of required backend. N)r/ isinstancestr importlib import_module FigureCanvas)r1 backend_classs r4get_registered_canvas_classr>tsN &&%f-M-%%!// >KK $1&! r6c^\rSrSrSrU4SjrS#SjrSrS#SjrS#Sjr S r S r S r S r S rSrSrS#SjrSrSrSS.SjrS$SjrSrSrSrSrSrSrSrSrSrSrS r S!r!S"r"U=r#$)% RendererBasea An abstract base class to handle drawing/rendering operations. The following methods must be implemented in the backend for full functionality (though just implementing `draw_path` alone would give a highly capable backend): * `draw_path` * `draw_image` * `draw_gouraud_triangles` The following methods *should* be implemented in the backend for optimization reasons: * `draw_text` * `draw_markers` * `draw_path_collection` * `draw_quad_mesh` c>[TU]5 SUl[R"5UlSUlSUlg)NrF)super__init__ _texmanagerr TextToPath _text2path _raster_depth _rasterizing)self __class__s r4rDRendererBase.__init__s4 //+!r6Ncg)zb Open a grouping element with label *s* and *gid* (if set) as id. Only used by the SVG renderer. N)rJsgids r4 open_groupRendererBase.open_groupr6cg)zJ Close a grouping element with label *s*. Only used by the SVG renderer. NrNrJrOs r4 close_groupRendererBase.close_grouprSr6c[e)z?Draw a `~.path.Path` instance using the given affine transform.NotImplementedError)rJgcpath transformrgbFaces r4 draw_pathRendererBase.draw_paths!!r6c URUSS9HVupx[U5(dMUSSupURXU[R"5R X5-U5 MX g)a Draw a marker at each of *path*'s vertices (excluding control points). The base (fallback) implementation makes multiple calls to `draw_path`. Backends may want to override this method in order to draw the marker only once and reuse it multiple times. Parameters ---------- gc : `.GraphicsContextBase` The graphics context. marker_path : `~matplotlib.path.Path` The path for the marker. marker_trans : `~matplotlib.transforms.Transform` An affine transform applied to the marker. path : `~matplotlib.path.Path` The locations to draw the markers. trans : `~matplotlib.transforms.Transform` An affine transform applied to the path. rgbFace : :mpltype:`color`, optional F)simplifyN) iter_segmentslenr_rr translate) rJr[ marker_path marker_transr\transr^verticescodesxys r4 draw_markersRendererBase.draw_markerssh. $11%%1HOH8}}}r+)224>>qD E&( Ir6c URUX45nURU[U5XVXxXXU 5 HPunnnnnUunnUS:wdUS:wa"UR5nUR UU5 UR UUUU5 MR g)a Draw a collection of *paths*. Each path is first transformed by the corresponding entry in *all_transforms* (a list of (3, 3) matrices) and then by *master_transform*. They are then translated by the corresponding entry in *offsets*, which has been first transformed by *offset_trans*. *facecolors*, *edgecolors*, *linewidths*, *linestyles*, and *antialiased* are lists that set the corresponding properties. *offset_position* is unused now, but the argument is kept for backwards compatibility. The base (fallback) implementation makes multiple calls to `draw_path`. Backends may want to override this in order to render each set of path data only once, and then reference that path multiple times with the different offsets, colors, styles etc. The generator methods `_iter_collection_raw_paths` and `_iter_collection` are provided to help with (and standardize) the implementation across backends. It is highly recommended to use those generators, so that changes to the behavior of `draw_path_collection` can be made globally. rN)_iter_collection_raw_paths_iter_collectionlistfrozenrfr_)rJr[master_transformpathsall_transformsoffsets offset_trans facecolors edgecolors linewidths linestyles antialiasedsurlsoffset_positionpath_idsxoyopath_idgc0r^r\r]s r4draw_path_collection!RendererBase.draw_path_collections6223C38J.2-B-BDNG O.5 )BGS'&OD)Qw"'&,,. ##B+ NN3i 9.5r6c SSKJn U RU5n U cUn [R"UR 5/[ 5n URXU /XgUX/U /S/S5 $)z| Draw a quadmesh. The base (fallback) implementation converts the quadmesh to paths and then calls `draw_path_collection`. r)QuadMeshNscreen)matplotlib.collectionsr_convert_mesh_to_pathsnparray get_linewidthfloatr)rJr[ru meshWidth meshHeight coordinatesrx offsetTransrz antialiasedr{rrvr|s r4draw_quad_meshRendererBase.draw_quad_meshsm 4// <  #JXXr//12E: (( %W: B vxI Ir6c[e)a Draw a series of Gouraud triangles. Parameters ---------- gc : `.GraphicsContextBase` The graphics context. triangles_array : (N, 3, 2) array-like Array of *N* (x, y) points for the triangles. colors_array : (N, 3, 4) array-like Array of *N* RGBA colors for each point of the triangles. transform : `~matplotlib.transforms.Transform` An affine transform to apply to the points. rY)rJr[triangles_array colors_arrayr]s r4draw_gouraud_triangles#RendererBase.draw_gouraud_triangless "!r6c## [U5n[U5n[XE5nUS:Xag[R"5n[ U5H)nX(U-n U(a[ X8U-5nXU-4v M+ g7f)a Helper method (along with `_iter_collection`) to implement `draw_path_collection` in a memory-efficient manner. This method yields all of the base path/transform combinations, given a master transform, a list of paths and list of transforms. The arguments should be exactly what is passed in to `draw_path_collection`. The backend should take each yielded path and transform and create an object that can be referenced (reused) later. rN)remaxrIdentityTransformranger) rJrurvrwNpaths NtransformsNr]ir\s r4rq'RendererBase._iter_collection_raw_paths"syU.)  $ Q; 002 qAV$D$^ O%DE $444 4 sA7A9c[U5nUS:Xd#[U5[U5s=:XaS:Xag Og[U[U55n[U[U55nX-S- U-$)aH Compute how many times each raw path object returned by `_iter_collection_raw_paths` would be used when calling `_iter_collection`. This is intended for the backend to decide on the tradeoff between using the paths in-line and storing them once and reusing. Rounds up in case the number of uses is not the same for every path. r)rer) rJrvrwrxrzr{r Npath_idsrs r4_iter_collection_uses_per_path+RendererBase._iter_collection_uses_per_path?sgU Q;#j/S_AABN 34  3w< ( !i//r6c ## [U5n [U5n [X5n[U5n[U5n[U5n[U5n[U 5nUS:XaUS:XdU S:XagUR5nURU5 SSjnU"U5nU"UR U5S5nU"U5nU"U5nU"U5nU"U5nU"U 5nU"U 5n US:XaUR S5 [ R"[UUUUUUUU 5U5GHununnn n!n"n#n$n%[R"U5(a[R"U5(dMHU(aiU(aUR U"5 U(aUR"U#6 [U!5S:XaU!SS:XaUR S5 OURU!5 U b[U 5S:Xa U SS:XaSn URU$5 U(aURU%5 UUUUU 4v GM UR5 g7f) a? Helper method (along with `_iter_collection_raw_paths`) to implement `draw_path_collection` in a memory-efficient manner. This method yields all of the path, offset and graphics context combinations to draw the path collection. The caller should already have looped over the results of `_iter_collection_raw_paths` to draw this collection. The arguments should be the same as that passed into `draw_path_collection`, with the exception of *path_ids*, which is a list of arbitrary objects that the backend will use to reference one of the paths created in the `_iter_collection_raw_paths` stage. Each yielded result is of the form:: xo, yo, path_id, gc, rgbFace where *xo*, *yo* is an offset; *path_id* is one of the elements of *path_ids*; *gc* is a graphics context and *rgbFace* is a color to use for filling the path. rNcz[U5(a[R"U5$[R"U5$N)re itertoolscyclerepeat)seqdefaults r4cycle_or_default7RendererBase._iter_collection..cycle_or_defaultxs.,/HHIOOC( 4"))'2 4r6)rrr)rernew_gccopy_propertiesr] set_linewidthrisliceziprisfinite set_dashesset_foregroundset_antialiasedset_urlrestore)&rJr[rrxryrzr{r|r}r~rrrNoffsetsr Nfacecolors Nedgecolors Nlinewidths NlinestylesNurlsrrpathidstoffsetsfcsecslwslssaaspathidrrfceclwlsaaurls& r4rrRendererBase._iter_collectionPs2Xw<  !*o *o *o *o D  1 !1fk kkm B 4 #8,#L$:$:7$CVLz*z*z*z*|,% !    c "9B9I9IGXsCc3Eq:J 5FHRb"b"b#KKOO B%%b)NNB'r7a-RendererBase._draw_disabled..str6)dirr@ startswithr)rJ meth_nameno_opss r4_draw_disabledRendererBase._draw_disabledsb!. . $$W-- == 4I3 3.  4*6** s A A )rHrIrErGr)FN)$__name__ __module__ __qualname____firstlineno____doc__rDrQrVr_rnrrrrqrrrrrrrrrrr rrr rrr)r,r/r3r@__static_attributes__ __classcell__rKs@r4r@r@s&"  " %)(>+:ZI*"$5:0"L\"@;?H. BD;6> %(    ++r6r@c>\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSr\R0S5rSrSrSrS*Sjr\R0S5rSrSr Sr!Sr"Sr#S r$S+S!jr%S"r&S#r'S$r(S%r)S&r*S,S(jr+S)r,g')-r#iz=An abstract base class that provides color, line styles, etc.chSUlSUlSUl[S5UlSUlSUlSUl[S5Ul SUl SUl SUl SUl [R"[ S 5Ul[ S UlSUlSUlSUlSUlg) NrFrbutt)rNroundsolid)rrrrz hatch.colorzhatch.linewidth)_alpha _forced_alpha _antialiasedr _capstyle _cliprect _clippath_dashesr _joinstyle _linestyle _linewidth_rgb_hatchr to_rgbar _hatch_color_hatch_linewidth_url_gid_snap_sketchrs r4rDGraphicsContextBase.__init__s "!&) #G,!(  "NN8M+BC (): ;    r6chURUlURUlURUlURUlURUlUR UlUR UlURUlURUlURUl URUl URUl URUl URUl URUlURUlUR UlUR"Ulg)z"Copy properties from *gc* to self.N)rOrPrQrRrSrTrUrVrWrXrYrZr\r]r^r_r`ra)rJr[s r4r#GraphicsContextBase.copy_propertiessii --OOzz ------GG ii OO " 3 3GG GG XX zz r6cg)zp Restore the graphics context from the stack - needed only for backends that save graphics contexts on a stack. NrNrs r4rGraphicsContextBase.restorerSr6cUR$)zK Return the alpha value used for blending - not supported on all backends. )rOrs r4 get_alphaGraphicsContextBase.get_alphas {{r6cUR$)zAReturn whether the object should try to do antialiased rendering.)rQrs r4get_antialiased#GraphicsContextBase.get_antialiased   r6c.URR$)zReturn the `.CapStyle`.)rRnamers r4 get_capstyle GraphicsContextBase.get_capstyles~~"""r6cUR$)zH Return the clip rectangle as a `~matplotlib.transforms.Bbox` instance. rSrs r4get_clip_rectangle&GraphicsContextBase.get_clip_rectangles~~r6cURbnURR5up[R"[R"UR 55(aX4$[ RS5 gg)z Return the clip path in the form (path, transform), where path is a `~.path.Path` instance, and transform is an affine transform to apply to the path before clipping. z/Ill-defined clip_path detected. Returning None.NN)rTget_transformed_path_and_affinerallrrj_logwarning)rJtpathtrs r4 get_clip_path!GraphicsContextBase.get_clip_pathsY >> %FFHIEvvbkk%..122y  NO!r6cUR$)zw Return the dash style as an (offset, dash-list) pair. See `.set_dashes` for details. Default value is (None, None). )rUrs r4 get_dashesGraphicsContextBase.get_dashess||r6cUR$)zj Return whether the value given by get_alpha() should be used to override any other alpha-channel values. )rPrs r4get_forced_alpha$GraphicsContextBase.get_forced_alphas !!!r6c.URR$)zReturn the `.JoinStyle`.)rVrors r4 get_joinstyle!GraphicsContextBase.get_joinstyle s###r6cUR$)z Return the line width in points.)rXrs r4r!GraphicsContextBase.get_linewidths r6cUR$)z0Return a tuple of three or four floats from 0-1.)rYrs r4rGraphicsContextBase.get_rgb yyr6cUR$)z+Return a url if one is set, None otherwise.r^rs r4get_urlGraphicsContextBase.get_urlrr6cUR$)z;Return the object identifier if one is set, None otherwise.r_rs r4get_gidGraphicsContextBase.get_gidrr6cUR$)z Return the snap setting, which can be: * True: snap vertices to the nearest pixel center * False: leave vertices as-is * None: (auto) If the path contains only rectilinear line segments, round to the nearest pixel center r`rs r4get_snapGraphicsContextBase.get_snap szzr6cvUbXlSUlOSUlSUlURURSS9 g)a Set the alpha value used for blending - not supported on all backends. If ``alpha=None`` (the default), the alpha components of the foreground and fill colors will be used to set their respective transparencies (where applicable); otherwise, ``alpha`` will override them. NTrF)isRGBA)rOrPrrY)rJalphas r4 set_alphaGraphicsContextBase.set_alpha+s=  K!%D DK!&D  DIId3r6c6[[U55Ulg)z>Set whether object should be drawn with antialiased rendering.N)intboolrQ)rJbs r4r#GraphicsContextBase.set_antialiased<s QLr6c$[U5Ulg)z] Set how to draw endpoints of lines. Parameters ---------- cs : `.CapStyle` or %(CapStyle)s N)rrR)rJcss r4 set_capstyle GraphicsContextBase.set_capstyleAs""r6cXlg)z,Set the clip rectangle to a `.Bbox` or None.Nrs)rJ rectangles r4set_clip_rectangle&GraphicsContextBase.set_clip_rectangleLs"r6cZ[R"[RS4US9 Xlg)z2Set the clip path to a `.TransformedPath` or None.N)r\)r check_isinstancerTransformedPathrT)rJr\s r4 set_clip_path!GraphicsContextBase.set_clip_pathPs" z994@tLr6c Uby[R"U5n[R"US:5(a [S5eUR(a)[R"US:5(d [S5eX4Ulg)a Set the dash style for the gc. Parameters ---------- dash_offset : float Distance, in points, into the dash pattern at which to start the pattern. It is usually set to 0. dash_list : array-like or None The on-off sequence as points. None specifies a solid line. All values must otherwise be non-negative (:math:`\ge 0`). Notes ----- See p. 666 of the PostScript `Language Reference `_ for more info. Nrz0All values in the dash list must be non-negativez4At least one value in the dash list must be positive)rasarrayany ValueErrorsizerU)rJ dash_offset dash_listdls r4rGraphicsContextBase.set_dashesUsr(  I&Bvvb3h FHHwwrvvb3h// JLL"- r6c&UR(a U(aUSSUR4-UlgUR(a&[R"XR5UlgU(aXlg[R"U5Ulg)z Set the foreground color. Parameters ---------- fg : :mpltype:`color` isRGBA : bool If *fg* is known to be an ``(r, g, b, a)`` tuple, *isRGBA* can be set to True to improve performance. Nr)rPrOrYr r[)rJfgrs r4r"GraphicsContextBase.set_foregroundss\   &2A$++/DI   r;;7DI Ir*DIr6c$[U5Ulg)zn Set how to draw connections between line segments. Parameters ---------- js : `.JoinStyle` or %(JoinStyle)s N)rrV)rJjss r4 set_joinstyle!GraphicsContextBase.set_joinstyles$B-r6c$[U5Ulg)zSet the linewidth in points.N)rrX)rJrs r4r!GraphicsContextBase.set_linewidths (r6cXlg)z-Set the url for links in compatible backends.Nr)rJrs r4rGraphicsContextBase.set_urls r6cXlg)z Set the id.Nr)rJids r4set_gidGraphicsContextBase.set_gids r6cXlg)z Set the snap setting which may be: * True: snap vertices to the nearest pixel center * False: leave vertices as-is * None: (auto) If the path contains only rectilinear line segments, round to the nearest pixel center Nr)rJsnaps r4set_snapGraphicsContextBase.set_snaps  r6cXlg)z Set the hatch style (for fills).NrZ)rJhatchs r4 set_hatchGraphicsContextBase.set_hatchs r6cUR$)zGet the current hatch style.rrs r4 get_hatchGraphicsContextBase.get_hatchs {{r6cVUR5nUcg[R"X!5$)z'Return a `.Path` for the current hatch.N)rrr)rJdensityrs r4get_hatch_path"GraphicsContextBase.get_hatch_paths%  =zz%))r6cUR$)zGet the hatch color.r\rs r4get_hatch_color#GraphicsContextBase.get_hatch_colorrmr6cXlg)zSet the hatch color.Nr)rJ hatch_colors r4set_hatch_color#GraphicsContextBase.set_hatch_colors'r6cUR$)zGet the hatch linewidth.r]rs r4get_hatch_linewidth'GraphicsContextBase.get_hatch_linewidths$$$r6cXlg)zSet the hatch linewidth.Nr)rJhatch_linewidths r4set_hatch_linewidth'GraphicsContextBase.set_hatch_linewidths /r6cUR$)a Return the sketch parameters for the artist. Returns ------- tuple or `None` A 3-tuple with the following elements: * ``scale``: The amplitude of the wiggle perpendicular to the source line. * ``length``: The length of the wiggle along the line. * ``randomness``: The scale factor by which the length is shrunken or expanded. May return `None` if no sketch parameters were set. rars r4get_sketch_params%GraphicsContextBase.get_sketch_paramss$||r6NcPUcSUlgX=(d SU=(d S4Ulg)a Set the sketch parameters. Parameters ---------- scale : float, optional The amplitude of the wiggle perpendicular to the source line, in pixels. If scale is `None`, or not provided, no sketch filter will be provided. length : float, default: 128 The length of the wiggle along the line, in pixels. randomness : float, default: 16 The scale factor by which the length is shrunken or expanded. Ng`@g0@r)rJrlength randomnesss r4set_sketch_params%GraphicsContextBase.set_sketch_paramss* MD 4):s; r6)rOrQrRrTrSrUrPr_rZr\r]rVrWrXrYrar`r^)F)g@)NNN)-rBrCrDrErFrDrrrhrkrprtr~rrrrrrrrrrrinterpdrrrrrrrrrrrrrrrrrrrrGrNr6r4r#r#sG("* !# "$ 4") &&# .<+(((# *!(%0(=r6r#c\rSrSrSrSSjrSr\R"SSSS 9SS j5r S r S r S r \ S5r\RS5r\ S5r\RS5rSrSrSrSrSrSrg) TimerBaseia A base class for providing timer events, useful for things animations. Backends need to implement a few specific methods in order to use their own timing mechanisms so that the timer events are integrated into their event loops. Subclasses must override the following methods: - ``_timer_start``: Backend-specific code for starting the timer. - ``_timer_stop``: Backend-specific code for stopping the timer. Subclasses may additionally override the following methods: - ``_timer_set_single_shot``: Code for setting the timer to single shot operating mode, if supported by the timer object. If not, the `Timer` class itself will store the flag and the ``_on_timer`` method should be overridden to support such behavior. - ``_timer_set_interval``: Code for setting the interval on the timer, if there is a method for doing so on the timer object. - ``_on_timer``: The internal function that any timer object should call, which will handle the task of running all callbacks that have been set. Nc^Uc/OUR5UlUcSOUUlSUlg)a Parameters ---------- interval : int, default: 1000ms The time between timer events in milliseconds. Will be stored as ``timer.interval``. callbacks : list[tuple[callable, tuple, dict]] List of (func, args, kwargs) tuples that will be called upon timer events. This list is accessible as ``timer.callbacks`` and can be manipulated directly, or the functions `~.TimerBase.add_callback` and `~.TimerBase.remove_callback` can be used. NiF)copy callbacksinterval single_shotrJrrs r4rDTimerBase.__init__ s/ )0inn6F ( 0h  r6c$UR5 g)z1Need to stop timer and possibly disconnect timer.N _timer_stoprs r4__del__TimerBase.__del__ r63.9rztimer.interval) alternativec6UbXlUR5 g)z Start the timer object. Parameters ---------- interval : int, optional Timer interval in milliseconds; overrides a previously set interval if provided. N)r _timer_startrJrs r4startTimerBase.start s  $M r6c$UR5 g)zStop the timer.Nrrs r4stopTimerBase.stop/rr6cgrrNrs r4rTimerBase._timer_start3 r6cgrrNrs r4rTimerBase._timer_stop6rr6cUR$)z/The time between timer events, in milliseconds.) _intervalrs r4rTimerBase.interval9s~~r6cZ[[U5S5nXlUR5 g)Nr)rrr_timer_set_intervalrs r4rr>s% s8}a(!   "r6cUR$)z2Whether this timer should stop after a single run.)_singlers r4rTimerBase.single_shotGs||r6c0XlUR5 gr)r_timer_set_single_shot)rJsss r4rrLs  ##%r6c@URRXU45 U$)z Register *func* to be called by timer when the event fires. Any additional arguments provided will be passed to *func*. This function returns *func*, which makes it possible to use it as a decorator. )rappend)rJfuncr8r9s r4 add_callbackTimerBase.add_callbackQs  t623 r6c,U(dU(a3[R"SSS9 URRXU45 gURVs/sHoDSPM nnX;a+URR UR U55 ggs snf)a Remove *func* from list of callbacks. *args* and *kwargs* are optional and used to distinguish between copies of the same function registered to be called with different arguments. This behavior is deprecated. In the future, ``*args, **kwargs`` won't be considered anymore; to keep a specific callback removable by itself, pass it to `add_callback` as a `functools.partial` object. z3.1zIn a future version, Timer.remove_callback will not take *args, **kwargs anymore, but remove all callbacks where the callable matches; to keep a specific callback removable by itself, pass it to add_callback as a functools.partial object.messagerN)r warn_deprecatedrremovepopindex)rJrr8r9cfuncss r4remove_callbackTimerBase.remove_callback\s| 6   , - NN ! !4v"6 7#'>>2>aqT>E2}""5;;t#453sBcg)z0Used to set interval on underlying timer object.NrNrs r4rTimerBase._timer_set_intervalsrSr6cg)z3Used to set single shot on underlying timer object.NrNrs r4r TimerBase._timer_set_single_shotvrSr6cURH3upnU"U0UD6nUS:XdMURRXU45 M5 [UR5S:XaUR5 gg)z Runs all function that have been registered as callbacks. Functions can return False (or 0) if they should not be called any more. If there are no callbacks, the timer is automatically stopped. rN)rr%rer )rJrr8r9rets r4 _on_timerTimerBase._on_timerysg #'.. D''C ax%%t6&:;#1 t~~ ! # IIK $r6)rrrrrrwr)rBrCrDrErFrDrr delete_parameterrr rrpropertyrsetterrrr*rrr2rGrNr6r4rrs2!$ 5*:JK L   __##&& 6.?Br6rc(\rSrSrSrSSjrSrSrg)Eventia^ A Matplotlib event. The following attributes are defined and shown with their default values. Subclasses may define additional attributes. Attributes ---------- name : str The event name. canvas : `FigureCanvasBase` The backend-specific canvas instance generating the event. guiEvent The GUI event that triggered the Matplotlib event. Nc(XlX lX0lgr)rocanvasguiEvent)rJror:r;s r4rDEvent.__init__s   r6crURRRURU5 SUlg)z?Process this event on ``self.canvas``, then unset ``guiEvent``.N)r:rprocessror;rs r4_processEvent._processs' %%dii6 r6)r:r;ror)rBrCrDrErFrDr?rGrNr6r4r8r8s ! r6r8c,^\rSrSrSrU4SjrSrU=r$) DrawEventia~ An event triggered by a draw operation on the canvas. In most backends, callbacks subscribed to this event will be fired after the rendering is complete but before the screen is updated. Any extra artists drawn to the canvas's renderer will be reflected without an explicit call to ``blit``. .. warning:: Calling ``canvas.draw`` and ``canvas.blit`` in these callbacks may not be safe with all backends and may cause infinite recursion. A DrawEvent has a number of special attributes in addition to those defined by the parent `Event` class. Attributes ---------- renderer : `RendererBase` The renderer for the draw event. c0>[TU]X5 X0lgr)rCrDr)rJror:rrKs r4rDDrawEvent.__init__s & r6rrBrCrDrErFrDrGrHrIs@r4rBrBs*!!r6rBc,^\rSrSrSrU4SjrSrU=r$) ResizeEventia  An event triggered by a canvas resize. A ResizeEvent has a number of special attributes in addition to those defined by the parent `Event` class. Attributes ---------- width : int Width of the canvas in pixels. height : int Height of the canvas in pixels. c^>[TU]X5 UR5uUlUlgr)rCrDrrr)rJror:rKs r4rDResizeEvent.__init__s' &"("9"9"; DKr6)rrrErIs@r4rGrGs <[TU]XUS9 Ub [U5OUUlUb [U5OUUlSUlSUlSUl[UbUO/5Ul UbUcgURURRcURR X445OURRX445 gN)r;) rCrDrrlrminaxesxdataydata frozensetrP _set_inaxesr: mouse_grabber)rJror:rlrmr;rPrKs r4rDLocationEvent.__init__s 9=Qa=Qa   " 0E92N 9   KK55=++QF322 !r6cXlUbSURR5RUbUOURUR 45uUlUlgg![a gf=fr) rS transDatainvertedr]rlrmrTrUr)rJrSxys r4rWLocationEvent._set_inaxes sj   )/)9)9)B)B)D)N)N.Btvvtvv.>*@& DJ   sAA A+*A+)rSrPrlrTrmrUr) rBrCrDrErF_last_axes_refrDrWrGrHrIs@r4rNrNs*&N!t!!4r6rNc(\rSrSrSrSrSrSrSrSr g) MouseButtonirr rNN) rBrCrDrELEFTMIDDLERIGHTBACKFORWARDrGrNr6r4raras D F E DGr6racD^\rSrSrSrSSSS.U4SjjjrSrSrU=r$) MouseEventia A mouse event ('button_press_event', 'button_release_event', 'scroll_event', 'motion_notify_event'). A MouseEvent has a number of special attributes in addition to those defined by the parent `Event` and `LocationEvent` classes. Attributes ---------- button : None or `MouseButton` or {'up', 'down'} The button pressed. 'up' and 'down' are used for scroll events. Note that LEFT and RIGHT actually refer to the "primary" and "secondary" buttons, i.e. if the user inverts their left and right buttons ("left-handed setting") then the LEFT button will be the one physically on the right. If this is unset, *name* is "scroll_event", and *step* is nonzero, then this will be set to "up" or "down" depending on the sign of *step*. buttons : None or frozenset For 'motion_notify_event', the mouse buttons currently being pressed (a set of zero or more MouseButtons); for other events, None. .. note:: For 'motion_notify_event', this attribute is more accurate than the ``button`` (singular) attribute, which is obtained from the last 'button_press_event' or 'button_release_event' that occurred within the canvas (and thus 1. be wrong if the last change in mouse state occurred when the canvas did not have focus, and 2. cannot report when multiple buttons are pressed). This attribute is not set for 'button_press_event' and 'button_release_event' because GUI toolkits are inconsistent as to whether they report the button state *before* or *after* the press/release occurred. .. warning:: On macOS, the Tk backends only report a single button even if multiple buttons are pressed. key : None or str The key pressed when the mouse event triggered, e.g. 'shift'. See `KeyEvent`. .. warning:: This key is currently obtained from the last 'key_press_event' or 'key_release_event' that occurred within the canvas. Thus, if the last change of keyboard state occurred while the canvas did not have focus, this attribute will be wrong. On the other hand, the ``modifiers`` attribute should always be correct, but it can only report on modifier keys. step : float The number of scroll steps (positive for 'up', negative for 'down'). This applies only to 'scroll_event' and defaults to 0 otherwise. dblclick : bool Whether the event is a double-click. This applies only to 'button_press_event' and is False otherwise. In particular, it's not used in 'button_release_event'. Examples -------- :: def on_press(event): print('you pressed', event.button, event.xdata, event.ydata) cid = fig.canvas.mpl_connect('button_press_event', on_press) N)buttonsrPc  L>[T U]XX4XS9 U[RR 5;a [U5nUS:XaUcUS:aSnOUS:aSnXPlUS:Xa[ U bU O/5UlOU (a [S5eSUlX`l Xpl Xl g)N)r;rP scroll_eventrupdownmotion_notify_eventz5'buttons' is only supported for 'motion_notify_event') rCrDra __members__valuesbuttonrVrlrkeystepdblclick) rJror:rlrmrtrurvrwr;rlrPrKs r4rDMouseEvent.__init__hs  !  H [,,335 5 (F > !fnax ( ($0CWLDL  KMMDL  r6cURSURSURSURSURSUR SUR SUR3$)Nz: xy=(, z ) xydata=(z ) button=z dblclick=z inaxes=)rorlrmrTrUrtrwrSrs r4__str__MouseEvent.__str__si99+vvhb 4::,b M++j@++( )r6)rtrlrwrurv)NNrFN) rBrCrDrErFrDr{rGrHrIs@r4rkrks1GR=A26!!!6))r6rkc2^\rSrSrSrSU4SjjrSrU=r$) PickEventiac A pick event. This event is fired when the user picks a location on the canvas sufficiently close to an artist that has been made pickable with `.Artist.set_picker`. A PickEvent has a number of special attributes in addition to those defined by the parent `Event` class. Attributes ---------- mouseevent : `MouseEvent` The mouse event that generated the pick. artist : `~matplotlib.artist.Artist` The picked artist. Note that artists are not pickable by default (see `.Artist.set_picker`). other Additional attributes may be present depending on the type of the picked object; e.g., a `.Line2D` pick may define different extra attributes than a `.PatchCollection` pick. Examples -------- Bind a function ``on_pick()`` to pick events, that prints the coordinates of the picked data point:: ax.plot(np.rand(100), 'o', picker=5) # 5 points tolerance def on_pick(event): line = event.artist xdata, ydata = line.get_data() ind = event.ind print(f'on pick line: {xdata[ind]:.3f}, {ydata[ind]:.3f}') cid = fig.canvas.mpl_connect('pick_event', on_pick) c >Uc URn[TU] XU5 X0lX@lUR R U5 gr)r;rCrD mouseeventartist__dict__update)rJror:rrr;r9rKs r4rDPickEvent.__init__s?  !**H x0$  V$r6)rrrrErIs@r4r~r~s$N%%r6r~c0^\rSrSrSrSU4SjjrSrU=r$)KeyEventiak A key event (key press, key release). A KeyEvent has a number of special attributes in addition to those defined by the parent `Event` and `LocationEvent` classes. Attributes ---------- key : None or str The key(s) pressed. Could be *None*, a single case sensitive Unicode character ("g", "G", "#", etc.), a special key ("control", "shift", "f1", "up", etc.) or a combination of the above (e.g., "ctrl+alt+g", "ctrl+alt+G"). Notes ----- Modifier keys will be prefixed to the pressed key and will be in the order "ctrl", "alt", "super". The exception to this rule is when the pressed key is itself a modifier key, therefore "ctrl+alt" and "alt+control" can both be valid key values. Examples -------- :: def on_key(event): print('you pressed', event.key, event.xdata, event.ydata) cid = fig.canvas.mpl_connect('key_press_event', on_key) c0>[TU]XXEUS9 X0lgrR)rCrDru)rJror:rurlrmr;rKs r4rDKeyEvent.__init__s qh?r6)ru)rrNrErIs@r4rrs>r6rcURS:XaURURlgURS:XaSURlgg)Nkey_press_eventkey_release_event)rorur:_key)events r4 _key_handlerrs= zz&&!II  * *   +r6c URS:XaURURlOZURS:XaSURlO8URS:Xa(URcURRUlURcURR UlURS:XGa[ RnU(aU"5OSnX R:waUb}URSS9Rn[ SUURURURURS9nURU5 URR!SU5 URb&URRR!SU5 UR(a [$R&"UR5OS[ lgg!["a N}f=f) Nbutton_press_eventbutton_release_eventrqTrootaxes_leave_eventrOaxes_enter_event)rortr:_buttonrurrNr_rS get_figurerlrmr;rPrWrr> Exceptionweakrefref)rlast_ref last_axesr: leave_events r4_mouse_handlerrs{ zz))$||  - -#  , ,1E||++  yyLL%%  zz** //"*HJ  $$ &11t1<CCF"/*F%.."'//#3K ++I6$$,,-?M||' &&../A5I).GKK %4 $-+$!s3A.DoneirNN)rBrCrDrErGrNr6r4Doners r6rc>T"U5errN)rrs r4_draw_get_renderer.._draws tH~-r6)drawNz6 did not call Figure.draw, so no renderer is available) rr rrr:get_default_filetype enter_context&_switch_canvas_and_return_print_methodioBytesIO RuntimeErrorr8)figure print_methodrstackfmtexcrrs @r4 _get_rendererrs y .   6 . u  --446C!.. DDSIKL <  & ,0: ;< <  IHO1< . . 1< . . .sS C7AC?B(C(C.C=C>C C7CC C+ 'C77 Dc$UR5 gr)draw_without_rendering)rs r4_no_output_drawr/s !!#r6c[US5=(a. URSL=(a [URSS5SL$)a6 Return whether we are in a terminal IPython, but non interactive. When in _terminal_ IPython, ip.parent will have and `interact` attribute, if this attribute is False we do not setup eventloop integration as the user will _not_ interact with IPython. In all other case (ZMQKernel, or is interactive), we do. parentNinteractF)hasattrrgetattr)ips r4$_is_non_interactive_terminal_ipythonr5s> B ! >$& > :t4=?r6c#v^^# [R"[R5nUS[R[R4;aSv gSm[ R "5up4URS5 URS5 [R"UR55nU"U5nUU4Sjn[R"[RU5 Sv UR5 UR5 [R"U5 [R"[RU5 TbU"T6 gg!UR5 UR5 [R"U5 [R"[RU5 TbU"T6 ff=f7f)a/ A context manager that allows terminating a plot by sending a SIGINT. It is necessary because the running backend prevents the Python interpreter from running and processing signals (i.e., to raise a KeyboardInterrupt). To solve this, one needs to somehow wake up the interpreter and make it close the plot window. We do this by using the signal.set_wakeup_fd() function which organizes a write of the signal number into a socketpair. A backend-specific function, *prepare_notifier*, arranges to listen to the pair's read socket while the event loop is running. (If it returns a notifier object, that object is kept alive while the context manager runs.) If SIGINT was indeed caught, after exiting the on_signal() function the interpreter reacts to the signal according to the handler function which had been set up by a signal.signal() call; here, we arrange to call the backend-specific *handle_sigint* function. Finally, we call the old SIGINT handler with the same arguments that were given to our custom handler. We do this only if the old handler for SIGINT was not None, which means that a non-python handler was installed, i.e. in Julia, and not SIG_IGN which means we should ignore the interrupts. Parameters ---------- prepare_notifier : Callable[[socket.socket], object] handle_sigint : Callable[[], object] NFc>UmT"5 grrN)r8 handle_sigint handler_argss r4save_args_and_handle_sigint5_allow_interrupt..save_args_and_handle_sigintls  r6) signal getsignalSIGINTSIG_IGNSIG_DFLsocket socketpair setblocking set_wakeup_fdfilenoclose) prepare_notifierrold_sigint_handlerwsockrsock old_wakeup_fdnotifierrrs ` @r4_allow_interruptrCs<: ))&--8dFNNFNNCC L$$&LE e e((8M&H  MM&--!<=.   ]+ fmm%78  #  - $   ]+ fmm%78  #  - $s C"F9'E+A%F9A&F66F9c^\rSrSrSrSr\R"S5r/SQr Sr \ r \RS5r S)U4Sjjr\"S5r\"S 5r\"S 5r\\R*S 55r\S 5r\S 5rSrS)SjrSrSrSrSrSr Sr!\S5r"Sr#SS.Sjr$\S5r%\S5r&\S)Sj5r'S*SSSSS.Sjjr(\S 5r)S!r*S"r+S#r,\-r.S+S$jr/S%r0S,S&jr1S'r2S(r3U=r4$)-FigureCanvasBasei}z The canvas the figure renders into. Attributes ---------- figure : `~matplotlib.figure.Figure` A high-level figure instance. Nc[$r)FigureManagerBaseclss r4r:FigureCanvasBase.s3Dr6) resize_event draw_eventrrrrrnrq pick_eventfigure_enter_eventfigure_leave_eventrr close_eventc@[US5=(a [US5$)z+If this Canvas sub-class supports blitting.copy_from_bboxrestore_region)rrs r4 supports_blitFigureCanvasBase.supports_blits$-.3C!12 4r6cd>SSKJn UR5 SUlSUlUcU"5nUR U5 XlSUl[R"5Ul SUl SUl SUl SUlSUlURUlSUl[$TU]M5 g)NrFigureTFr)matplotlib.figurer_fix_ipython_backend2gui_is_idle_drawing _is_saving set_canvasrmanagerrLockDraw widgetlockrrrXtoolbarr _original_dpi_device_pixel_ratiorCrD)rJrrrKs r4rDFigureCanvasBase.__init__s, %%' $ >XF$  !**,  ! %%zz#$  r6c.URR$r)r_canvas_callbacksrs r4r:rsdkk&C&Cr6c.URR$r)r_button_pick_idrs r4r:r4;;+F+Fr6c.URR$r)r_scroll_pick_idrs r4r:rrr6c[RRS5nUbURSSS:agSSKnUR 5nU(dgSSKJn [US5(a[US5(dgSS S S S S .RUR5nU(a#[U5(aURU5 ggg)NIPythonrb)rcr) pylabtools backend2guienable_matplotlibqtgtk3gtk4wxosx)rrrrmacosx) sysmodulesget version_infor get_ipython IPython.corerrrequired_interactive_frameworkr enable_gui)r mod_ipythonrrptbackend2gui_rifs r4r)FigureCanvasBase._fix_ipython_backend2guiskkooi0  +":":2A">'"I   " 1M**r#677   #c00 1  3B77 o.8 r6c:URRXU5$)z Create a new figure manager for *figure*, using this canvas class. Notes ----- This method should not be reimplemented in subclasses. If custom manager creation logic is needed, please reimplement ``FigureManager.create_with_canvas``. ) manager_classcreate_with_canvas)rrnums r4 new_managerFigureCanvasBase.new_managers  33CEEr6c#J# SUlSv SUlg!SUlf=f7f)NTF)rrs r4_idle_draw_cntx FigureCanvasBase._idle_draw_cntxs% $ * $)D !ED !s## #cUR$)zs Return whether the renderer is in the process of saving to a file, rather than rendering for an on-screen buffer. rrs r4 is_savingFigureCanvasBase.is_savings r6cg)z0Blit the canvas in bbox (default entire canvas).NrN)rJbboxs r4blitFigureCanvasBase.blitrSr6cURR5Vs/sH>nURRU5(dM%UR 5(dM<UPM@ nnU(a[ R "U5nU$SnU$s snf)a= Return the topmost visible `~.axes.Axes` containing the point *xy*. Parameters ---------- xy : (float, float) (x, y) pixel positions from left/bottom of the canvas. Returns ------- `~matplotlib.axes.Axes` or None The topmost visible Axes containing the point, or None if there is no Axes at the point. N)rget_axespatchcontains_point get_visibler _topmost_artist)rJr]a axes_listaxess r4rSFigureCanvasBase.inaxes s|!% 4 4 6H 61..r278}} 6 H ((3D D Hs$BBBcJURSU4;a [S5eXlg)z Set the child `~.axes.Axes` which is grabbing the mouse events. Usually called by the widgets themselves. It is an error to call this if the mouse is already grabbed by another Axes. Nz&Another Axes already grabs mouse input)rXrrJaxs r4 grab_mouseFigureCanvasBase.grab_mouse#s(   dBZ /GH Hr6c2URULaSUlgg)z Release the mouse grab held by the `~.axes.Axes` *ax*. Usually called by the widgets. It is ok to call this even if *ax* doesn't have the mouse grab currently. N)rXr1s r4 release_mouseFigureCanvasBase.release_mouse.s    #!%D  $r6cg)a Set the current cursor. This may have no effect if the backend does not display anything. If required by the backend, this method should trigger an update in the backend event loop after the cursor is set, as this method may be called e.g. before a long-running task during which the GUI is not updated. Parameters ---------- cursor : `.Cursors` The cursor to display over the canvas. Note: some backends may change the cursor for the entire window. NrN)rJcursors r4 set_cursorFigureCanvasBase.set_cursor8rSr6cg)z Render the `.Figure`. This method must walk the artist tree, even if no output is produced, because it triggers deferred work that users may want to access before saving output to disk. For example computing limits, auto-limits, and tick values. NrNrJr8r9s r4rFigureCanvasBase.drawJrSr6cUR(d,UR5 UR"U0UD6 SSS5 gg!,(df  g=f)aA Request a widget redraw once control returns to the GUI event loop. Even if multiple calls to `draw_idle` occur before control returns to the GUI event loop, the figure will only be rendered once. Notes ----- Backends may choose to override the method and implement their own strategy to prevent multiple renderings. N)rrrr=s r4 draw_idleFigureCanvasBase.draw_idleTs>$$%%' 4*6*('%''s ? A cUR$)aa The ratio of physical to logical pixels used for the canvas on screen. By default, this is 1, meaning physical and logical pixels are the same size. Subclasses that support High DPI screens may set this property to indicate that said ratio is different. All Matplotlib interaction, unless working directly with the canvas, remains in logical pixels. rrs r4device_pixel_ratio#FigureCanvasBase.device_pixel_ratioes'''r6cURU:XagXRR-nURRUSS9 Xlg)aP Set the ratio of physical to logical pixels used for the canvas. Subclasses that support High DPI screens can set this property to indicate that said ratio is different. The canvas itself will be created at the physical size, while the client side will use the logical size. Thus the DPI of the Figure will change to be scaled by this ratio. Implementations that support High DPI screens should use physical pixels for events so that transforms back to Axes space are correct. By default, this is 1, meaning physical and logical pixels are the same size. Parameters ---------- ratio : float The ratio of logical to physical pixels used for the canvas. Returns ------- bool Whether the ratio has changed. Backends may interpret this as a signal to resize the window, repaint the canvas, or change any other relevant properties. F)forwardT)rrr_set_dpi)rJratiors r4_set_device_pixel_ratio(FigureCanvasBase._set_device_pixel_ratiorsI6  # #u , kk/// S%0#( r6F)physicalcn^^[UU4SjTRRR55$)a< Return the figure width and height in integral points or pixels. When the figure is used on High DPI screens (and the backend supports it), the truncation to integers occurs after scaling by the device pixel ratio. Parameters ---------- physical : bool, default: False Whether to return true physical pixels or logical pixels. Physical pixels may be used by backends that support HiDPI, but still configure the canvas using its actual size. Returns ------- width, height : int The size of the figure, in points or pixels, depending on the backend. c3f># UH&n[UT(aSO TR- 5v M( g7f)rN)rrD).0rrLrJs r4 4FigureCanvasBase.get_width_height..s/7!5hD4K4KLMM!5s.1)tuplerr#r)rJrLs``r4r!FigureCanvasBase.get_width_heights/*7!%!1!1!5!577 7r6cUR$)z>Return dict of savefig file formats supported by this backend.) filetypesrs r4get_supported_filetypes(FigureCanvasBase.get_supported_filetypess}}r6c0nURR5H8up#URU/5RU5 XR 5 M: U$)z Return a dict of savefig file formats supported by this backend, where the keys are a file type name, such as 'Joint Photographic Experts Group', and the values are a list of filename extensions used for that filetype, such as ['jpg', 'jpeg']. )rUitems setdefaultrsort)r groupingsextros r4get_supported_filetypes_grouped0FigureCanvasBase.get_supported_filetypes_groupedsS ,,.IC  r * 1 1# 6 O "/r6c #^ ^ # SnUb[SSKJn URU5Rn[ USU35(d[ SU<SUS35eU"UR 5nOx[ USU35(aUnOa[U5nUcA[ SRUS R[UR55555eU"UR 5nURUl [USU35m [ T S 5(aT RRO T RnUR!S 5(aK1S knU1["R$"T 5R&k- m [(R*"T 5"U U 4S j5nOT nUv XR lg!XR lf=f7f)an Context manager temporarily setting the canvas for saving the figure:: with (canvas._switch_canvas_and_return_print_method(fmt, backend) as print_method): # ``print_method`` is a suitable ``print_{fmt}`` method, and # the figure's canvas is temporarily switched to the method's # canvas within the with... block. ``print_method`` is also # wrapped to suppress extra kwargs passed by ``print_figure``. Parameters ---------- fmt : str If *backend* is None, then determine a suitable canvas class for saving to format *fmt* -- either the current canvas class, if it supports *fmt*, or whatever `get_registered_canvas_class` returns; switch the figure canvas to that canvas class. backend : str or None, default: None If not None, switch the figure canvas to the ``FigureCanvas`` class of the given backend. Nr)backend_registryprint_zThe z backend does not support z outputz4Format {!r} is not supported (supported formats: {})rzr)z matplotlib.z mpl_toolkits.>r edgecolor facecolor orientationbbox_inches_restorec v>T"U0UR5VVs0sHup#UT;dM X#_M snnD6$s snnfr)rY)r8r9kvmethskips r4r:IFigureCanvasBase._switch_canvas_and_return_print_method..s=JM+1<<>K>41Qd]$!$>KJMKs 55)backends.registryraload_backend_moduler<rrrr>r1joinsortedrVrrrrCr=inspect signature parameters functoolswrapsr:) rJrr2r:ra canvas_classmod optional_kwsrrjrks @@r4r7FigureCanvasBase._switch_canvas_and_return_print_methods.   ;+??HUUL<6#88 7+%?uGLNN!$++.F TVC5> * *F7s;L# JQQTYYvd.J.J.L'MNPQQ"$++.F OOvu~.$''yy##OO  >>: ; ;'L "GG$5$5d$;$F$F"GGD$??402MNL L & !%KK KK sFF>F)F>)F;;F>) bbox_inches pad_inchesbbox_extra_artistsr2c Uc[U[R5(a[R"U5n[U[5(a%[R R U5SSSnUbUS:Xa<UR5n[U[5(aURS5S-U-nUR5nUc [SnUS:Xa+[URSURR5n[R"USS9 UR!Xj5n [R"URUS 9 [R"URR"SS 9 [R"URR"S S 9 [%5n S Hin['5UnUc [SU3n[R("US5(aM=U R+URR,"S0X0D65 Mk Uc [SnURR/5nUcUS:Xab[1UR[2R4"XS95n[US[65"5 URR9U5 SSS5 U(aUS:XaURR;WU S9n[U[<5(a-US:Xa'UR?5SnUR?5SnOUS;a [SnU=nnURAUU5n[BRD"URXpRR"RF5nUU4nOSnU R+URR-SS95 [R"URUS 9 U "U4UUUUS.U D6nSSS5 U(aW(aU"5 WsSSS5 sSSS5 sSSS5 sSSS5 sSSS5 sSSS5 $!,(df  GN=f!,(df  Nm=f!U(aW(aU"5 fff=f!,(df  O=fSSS5 O!,(df  O=fSSS5 O!,(df  O=fSSS5 O!,(df  O=fSSS5 O!,(df  O=fSSS5 g!,(df  g=f)a+ Render the figure to hardcopy. Set the figure patch face and edge colors. This is useful because some of the GUIs have a gray figure face color background and you'll probably want to override this on hardcopy. Parameters ---------- filename : str or path-like or file-like The file where the figure is saved. dpi : float, default: :rc:`savefig.dpi` The dots per inch to save the figure in. facecolor : :mpltype:`color` or 'auto', default: :rc:`savefig.facecolor` The facecolor of the figure. If 'auto', use the current figure facecolor. edgecolor : :mpltype:`color` or 'auto', default: :rc:`savefig.edgecolor` The edgecolor of the figure. If 'auto', use the current figure edgecolor. orientation : {'landscape', 'portrait'}, default: 'portrait' Only currently applies to PostScript printing. format : str, optional Force a specific file format. If not given, the format is inferred from the *filename* extension, and if that fails from :rc:`savefig.format`. bbox_inches : 'tight' or `.Bbox`, default: :rc:`savefig.bbox` Bounding box in inches: only the given portion of the figure is saved. If 'tight', try to figure out the tight bbox of the figure. pad_inches : float or 'layout', default: :rc:`savefig.pad_inches` Amount of padding in inches around the figure when bbox_inches is 'tight'. If 'layout' use the padding from the constrained or compressed layout engine; ignored if one of those engines is not in use. bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional A list of extra artists that will be considered when the tight bbox is calculated. backend : str, optional Use a non-default backend to render the file, e.g. to render a png file with the "cairo" backend rather than the default "agg", or a pdf file with the "pgf" backend rather than the default "pdf". Note that the default backend is normally sufficient. See :ref:`the-builtin-backends` for a list of valid backends for each file format. Custom backends can be referenced as "module://...". Nrr..z savefig.dpirr)r)rrCTr)rdrczsavefig.autoz savefig.bboxtight)rer@)r|layouth_padw_pad)Nrzsavefig.pad_inchesnone) layout_engine)rdrcrerfrN)$r8osPathLikefspathr9r\splitextrrstriplowerrrrrr rrr:rlocals _str_equalr_cm_setget_layout_enginerrtpartialrr get_tightbboxrr paddedr adjust_bbox fixed_dpi)rJfilenamerrdrcrer1rzr{r|r2r9rrrrrrrr restore_bbox_bbox_inches_restoreresults r4 print_figureFigureCanvasBase.print_figuresr >(BKK0099X.(C(())(3A6qr:~2224h,,'s3c9FBH ;=)C (?$++ HCd399&J  5 2 2J 2 2tDkU2=$xv%67E''v66'' (;(;(Ltm(LM 3"&~6  KK99;M(K7,B)KK%%$?X'7EGKK$$X.H')"&++";"; 5G#<#IK"=2IJJ&(2 - 1 1 3G < - 1 1 3G <%)99)12F)GJ(22"-"4"4UE"BK +66KKkk.@.@.J.J L )4\'B$'+$    3 3& 3 I J #&&t{{<) ""+"+$/,@ " ! "F=< NCkEDKJ65KJ43<HG:=<< N$0;}kkEDDKJJ655KJJ433sS., S *R:6*R R +Q Q+ 5 R > R  R: S S., P;6Q+ > Q Q Q((Q+ + Q95R = R  RR  R: R. *R:1 S: S S S. S" S.. S<c[S$)z Return the default savefig file format as specified in :rc:`savefig.format`. The returned string does not include a period. This method is overridden in backends that only support a single file type. zsavefig.format)rrs r4r%FigureCanvasBase.get_default_filetypes())r6cURbURR5OSnU=(d SnSnURUVs0sHn[U5S_M sn5nUR 5nUSU3$s snf)z> Return a suitable default filename, including the extension. r.imagez <>:"/\|?*\0 _r~)rget_window_titlerfordr)rJdefault_basename removed_charsr(default_filetypes r4get_default_filename%FigureCanvasBase.get_default_filenames ||' LL ) ) +  ,6w( +55"/ 0-QSVS[- 02446"#1%5$677 1sA:c8URRX5$)a0 Bind function *func* to event *s*. Parameters ---------- s : str One of the following events ids: - 'button_press_event' - 'button_release_event' - 'draw_event' - 'key_press_event' - 'key_release_event' - 'motion_notify_event' - 'pick_event' - 'resize_event' - 'scroll_event' - 'figure_enter_event', - 'figure_leave_event', - 'axes_enter_event', - 'axes_leave_event' - 'close_event'. func : callable The callback function to be executed, which must have the signature:: def func(event: Event) -> Any For the location events (button and key press/release), if the mouse is over the Axes, the ``inaxes`` attribute of the event will be set to the `~matplotlib.axes.Axes` the event occurs is over, and additionally, the variables ``xdata`` and ``ydata`` attributes will be set to the mouse location in data coordinates. See `.KeyEvent` and `.MouseEvent` for more info. .. note:: If func is a method, this only stores a weak reference to the method. Thus, the figure does not influence the lifetime of the associated object. Usually, you want to make sure that the object is kept alive throughout the lifetime of the figure by holding a reference to it. Returns ------- cid A connection id that can be used with `.FigureCanvasBase.mpl_disconnect`. Examples -------- :: def on_press(event): print('you pressed', event.button, event.xdata, event.ydata) cid = canvas.mpl_connect('button_press_event', on_press) )rconnect)rJrOrs r4 mpl_connectFigureCanvasBase.mpl_connectsz~~%%a..r6c:URRU5 g)z Disconnect the callback with id *cid*. Examples -------- :: cid = canvas.mpl_connect('button_press_event', on_press) # ... later canvas.mpl_disconnect(cid) N)r disconnect)rJcids r4mpl_disconnectFigureCanvasBase.mpl_disconnects !!#&r6c URXS9$)aP Create a new backend-specific subclass of `.Timer`. This is useful for getting periodic events through the backend's native event loop. Implemented only for backends with GUIs. Parameters ---------- interval : int Timer interval in milliseconds. callbacks : list[tuple[callable, tuple, dict]] Sequence of (func, args, kwargs) where ``func(*args, **kwargs)`` will be executed by the timer every *interval*. Callbacks which return ``False`` or ``0`` will be removed from the timer. Examples -------- >>> timer = fig.canvas.new_timer(callbacks=[(f1, (1,), {'a': 3})]) )rr) _timer_clsrs r4 new_timerFigureCanvasBase.new_timer s.FFr6cg)z] Flush the GUI events for the figure. Interactive backends need to reimplement this method. NrNrs r4 flush_eventsFigureCanvasBase.flush_events rSr6c US::a[RnSnSnSUlUR(aQX2-U:aHUR5 [R "U5 US- nUR(a X2-U:aMFgggg)a Start a blocking event loop. Such an event loop is used by interactive functions, such as `~.Figure.ginput` and `~.Figure.waitforbuttonpress`, to wait for events. The event loop blocks until a callback function triggers `stop_event_loop`, or *timeout* is reached. If *timeout* is 0 or negative, never timeout. Only interactive backends need to reimplement this method and it relies on `flush_events` being properly implemented. Interactive backends should implement this in a more native way. rg{Gz?TrN)rinf_loopingrtimesleep)rJtimeouttimestepcounters r4start_event_loop!FigureCanvasBase.start_event_loop$ sq$ a<ffG mm 2W <     JJx qLGmm 2W RA[CU 55 UR;S5 Sn A GNBSn A ff=f![6a9n [>RA[CU 55 URGS5 Sn A NSn A ff=f)ak Implement the default Matplotlib key bindings for the canvas and toolbar described at :ref:`key-event-handling`. Parameters ---------- event : `KeyEvent` A key press/release event. canvas : `FigureCanvasBase`, default: ``event.canvas`` The backend-specific canvas instance. This parameter is kept for back-compatibility, but, if set, should always be equal to ``event.canvas``. toolbar : `NavigationToolbar2`, default: ``event.canvas.toolbar`` The navigation cursor toolbar. This parameter is kept for back-compatibility, but, if set, should always be equal to ``event.canvas.toolbar``. Nzkeymap.fullscreenz keymap.quitzkeymap.quit_allz keymap.home keymap.backkeymap.forwardz keymap.panz keymap.zoomz keymap.savecj[SU55(aS$[SU55(dS$S$)Nc3T# UHoRR5v M g7frgridliner*rOticks r4rPDkey_press_handler.._get_uniform_gridstate.. sJEDMM5577E&(Tc3T# UHoRR5v M g7frrrs r4rPr s O!:!:!._get_uniform_gridstate s<JEJJJ  O OOO  r6z keymap.grid))FF)TF)TT)FTrmajorbothrl)whichaxisrmzkeymap.grid_minorz keymap.yscaleloglinearTrz keymap.xscale)$rur:rrrfull_screen_toggleAttributeErrorr destroy_figr destroy_allhomebackrGpan_update_cursorzoom save_figurerSxaxis minorTicksyaxis majorTicksr'regridr@r get_yscale set_yscalerrzr{r9 get_xscale set_xscale) rr:rrr2x_statey_staterrrscalexs r4key_press_handlerrJ s$ yy ~.. yyH011  NN - - /  yyH]++  & yyH.//  99/ / LLNYY(=1 1 LLN YY(#34 4 OO  YY(<0 0 KKM  " "5 ) YY(=1 1 LLN  " "5 ) YY(=1 1    ! || B  Xm,,3BHH4G4GH3BHH4G4GHJJ()<)<=()<)<=L {{G#56:c%jHI G GGGg76G L GGGg76G L     X1223BHH4G4GH3BHH4G4GHJJ()<)<=()<)<=L {{G#56:c%jHI G GGG6G 4 GGG6G 4     h/ /  E> MM( # MMtM $ + + 5 5 7 h  ( e$ MMtM $ + + 5 5 7  h/ / U? MM( # MMtM $ + + 5 5 7 x  ( e$ MMtM $ + + 5 5 7  0E   t   &     ( SX& h'' ( ( SX& h'' (sfT"%T3;%UU'V" T0/T03 UU UU V/VV W%/WWcUc URnUc URnUb[[[UR55nU[ S;aUR 5 gU[ S;aUR5 ggg)z The default Matplotlib button actions for extra mouse buttons. Parameters are as for `key_press_handler`, except that *event* is a `MouseEvent`. Nrr)r:rr9rartrrrG)rr:r button_names r4button_press_handlerr sq~..+ell34 (=1 1 LLN H%56 6 OO 7 r6c\rSrSrSrSrg)NonGuiExceptioni z6Raised when trying show a figure in a non-GUI backend.rNNrLrNr6r4rr s@r6rc\rSrSrSrSrSrSr\S5r \S5r \SS.Sj5r S r S r S rS rS rSrSrg)ri ae A backend-independent abstraction of a figure container and controller. The figure manager is used by pyplot to interact with the window in a backend-independent way. It's an adapter for the real (GUI) framework that represents the visual figure on screen. The figure manager is connected to a specific canvas instance, which in turn is connected to a specific figure instance. To access a figure manager for a given figure in user code, you typically use ``fig.canvas.manager``. GUI backends derive from this class to translate common operations such as *show* or *resize* to the GUI-specific code. Non-GUI backends do not support these operations and can just use the base class. This following basic operations are accessible: **Window operations** - `~.FigureManagerBase.show` - `~.FigureManagerBase.destroy` - `~.FigureManagerBase.full_screen_toggle` - `~.FigureManagerBase.resize` - `~.FigureManagerBase.get_window_title` - `~.FigureManagerBase.set_window_title` **Key and mouse button press handling** The figure manager sets up default key and mouse button press handling by hooking up the `.key_press_handler` to the matplotlib event system. This ensures the same shortcuts and mouse actions across backends. **Other operations** Subclasses will have additional attributes and functions to access additional functionality. This is of course backend-specific. For example, most GUI backends have ``window`` and ``toolbar`` attributes that give access to the native GUI widgets of the respective framework. Attributes ---------- canvas : `FigureCanvasBase` The backend-specific canvas instance. num : int or str The figure number. key_press_handler_id : int The default key handler cid, when using the toolmanager. To disable the default key press handling use:: figure.canvas.mpl_disconnect( figure.canvas.manager.key_press_handler_id) button_press_handler_id : int The default mouse button handler cid, when using the toolmanager. To disable the default button press handling use:: figure.canvas.mpl_disconnect( figure.canvas.manager.button_press_handler_id) Nc^UTlTUlUTlTRSUS35 STlSTl[ SS:waJTRRS[5TlTRRS[5Tl[R SS:Xa[UR5OSTl [R SS:Xa2TR(a!TRTR5TlOP[R SS:Xa2TR (a!TR!TR5TlOSTlTR(aQ["R$"TR5 TR(a ["R&"TR5 TRRR(U4Sj5ng) NzFigure rr toolmanagerrrtoolbar2cr>TRc)TRbTRR5 gggr)rrr)figrJs r4notify_axes_change6FigureManagerBase.__init__..notify_axes_changeP s3'DLL,D ##%-E'r6)r:rrset_window_titlekey_press_handler_idbutton_press_handler_idrrrrmplrrr_toolbar2_classr_toolmanager_toolbar_classtoolsadd_tools_to_manageradd_tools_to_containeradd_axobserver)rJr:rrs` r4rDFigureManagerBase.__init__1 su  Aw/0$(!'+$ I - /(, (?(?!#4)6D %+/;;+B+B$&:,n.>*>E     ! # -""3s8,, -sB'' C1CCc[RS:Xa%[RR S5(dg[ [ UR5RS35e)z For GUI backends, show the figure window and redraw. For non-GUI backends, raise an exception, unless running headless (i.e. on Linux with an unset DISPLAY); this exception is converted to a warning in `.Figure.show`. linuxDISPLAYNz- is non-interactive, and thus cannot be shown) r platformrenvironr rtyper:rBrs r4rFigureManagerBase.show sS <<7 "2::>>)+D+D DKK ))*+  r6cgrrNrs r4destroyFigureManagerBase.destroy rr6cgrrNrs r4r$FigureManagerBase.full_screen_toggle rr6cg)z9For GUI backends, resize the window (in physical pixels).NrN)rJrrs r4resizeFigureManagerBase.resize rSr6cg)zp Return the title text of the window containing the figure, or None if there is no window (e.g., a PS backend). rrNrs r4r"FigureManagerBase.get_window_title s r6cg)z Set the title text of the window containing the figure. This has no effect for non-GUI (e.g., PS) backends. Examples -------- >>> fig = plt.figure() >>> fig.canvas.manager.set_window_title('My figure') NrN)rJtitles r4r"FigureManagerBase.set_window_title rSr6)rr:rrrr)rBrCrDrErFrr rDrrrrrr)rr.rrrGrNr6r4rr sz<|O!%#&J..    "& " "D$  H  r6rc6\rSrSrSrSrSrSr\S5r Sr g) _Modei r.zpan/zoomz zoom rectcUR$r)valuers r4r{ _Mode.__str__ s zzr6cDU[RLa UR$S$r)r6NONErors r4_navigate_mode_Mode._navigate_mode s  2tyy< s, !   " r6cUR(GafUR(GaTURR5(Ga4UR[R:Xa{UR [ RR:waSURR[ RR5 [ RRUlgUR[R:Xa|UR [ RR:waSURR[ RR5 [ RRUlgggUR [ RR:waSURR[ RR5 [ RRUlgg)zF Update the cursor after a mouse move event or a tool (de)activation. N)r\rS get_navigater6r?rTr rR SELECT_REGIONr:r:r>MOVErSrJrs r4r!NavigationToolbar2._update_cursorJ s* 999%,,*C*C*E*E UZZ'))U]]-H-HH &&u}}'B'BC$)MM$?$?!))uyy(''5==+=+== &&u}}'9'9:$)MM$6$6!>)  %--"7"7 7 KK " "5==#8#8 9 % 5 5D 8r6c## [R"5[US[R*5sUlnURU- S:a^UR R [RR5 Sv UR R UR5 gSv g!UR R UR5 f=f7f)aY Set the cursor to a wait cursor when drawing the canvas. In order to avoid constantly changing the cursor when the canvas changes frequently, do nothing if this context was triggered during the last second. (Optimally we'd prefer only setting the wait cursor if the *current* draw takes too long, but the current draw blocks the GUI thread). _draw_timerN) rrrrr|r:r:r rRWAITrT)rJlast_draw_times r4_wait_cursor_for_draw_cm+NavigationToolbar2._wait_cursor_for_draw_cm[ s IIK|bffW= ( ??^ +a / : &&u}}'9'9: &&t'8'89  &&t'8'89sA C7B0+C0'CCcUR(Ga2URR5(GaURRURUR5nUR 5nURR Vs/sH7nURU5S(dMUR5(dM5UPM9 nnU(ap[R"U5nX RRLaBURU5nUb.URU5R 5nU(aUS-U-nU$gs snf![[4a gf=f)Nr r.)rSrv format_coordrTrUr_mouseover_setcontainsr*r r+r(get_cursor_dataformat_cursor_datar OverflowError)rrOr,artistsdatadata_strs r4_mouse_event_to_message*NavigationToolbar2._mouse_event_to_messageq s$ <<ro press_pan release_panr? press_zoom release_zoomrys r4rU$NavigationToolbar2._zoom_pan_handler s 99 !zz11u%55  ' 99 "zz11&55!!%(6 #r6c^^UU4SjnSn[[X0RRR 555n[ U5S:Xa/$UR 5cUR5 [5n[U5H2nURUR5/5RU5 M4 /n[USS9HZn XiHMnURU5 URURR!U55 U"U5(dMM O MZ O [[R#U55nU$)Nc>URT5=(a+ UR5=(a [UST35"5$)Ncan_)in_axesrvr)r2rmethods r4 _ax_filterDNavigationToolbar2._start_event_axes_interaction.._ax_filter s;JJu%3OO%3B$vh02 r6czUR5nUS:XaURR5(+nU(+$)Nr)get_forward_navigation_eventsr(r*)r2fs r4_capture_eventsINavigationToolbar2._start_event_axes_interaction.._capture_events s3002AF{,,..5Lr6rT)reverse)rsfilterr:rr'rerQ push_currentdictreversedrZ get_zorderrrpextend _twinned_axes get_siblingsfromkeys) rJrrrrr.grpsr2axes_to_triggerzorders `` r4_start_event_axes_interaction0NavigationToolbar2._start_event_axes_interaction s   F:{{'9'9'B'B'DEF t9>I ??  $    v4.B OOBMMOR 0 7 7 ;!T40Fl&&r*&&r'7'7'D'DR'HI"2&& # !1&t}}_=>r6c.URRRU5(dURS5 gUR[ R :Xa;[ RUlURRRU5 O0[ R UlURRU5 URRR5H(nURURR5 M* g)zC Toggle the pan/zoom tool. Pan with left button, zoom with right. zpan unavailableN) r:r availabler`r\r6r>r;releaserr'set_navigate_moder<rJr8r,s r4rNavigationToolbar2.pan s {{%%//55   . /  99 ! DI KK " " * *4 0 DI KK " "4 (##,,.A   8 8 9/r6_PanInfozbutton axes cidcUR[R[R4;dURb UR cgUR USS9nU(dgUH4nURURUR UR5 M6 URRUR5 URRSUR5nURURX$S9Ulg)z1Callback for mouse button press in pan/zoom mode.Nrrrq)rtr.r)rtrarergrlrmr start_panr:rrYrdrag_panrrZ)rJrr.r2id_drags r4rNavigationToolbar2.press_pan s LL!1!1;3D3D E E77?eggo 11%1F B LL%''5<< 8 ""4==1++))*?O<> !  ""4>>#5#56 // !4??4 ..%%B JJL&  r6c0URRRU5(dURS5 gUR[ R :Xa;[ RUlURRRU5 O0[ R UlURRU5 URRR5H(nURURR5 M* g)Nzzoom unavailable) r:rrr`r\r6r?r;rrr'rr<rs r4rNavigationToolbar2.zoom s{{%%//55   / 0 ' 99 " DI KK " " * *4 0 DI KK " "4 (##,,.A   8 8 9/r6 _ZoomInfoz direction start_xy axes cid cbarcUR[R[R4;dURb UR cgUR USS9nU(dgURRSUR5nUSn[US5(aURRnOSnURURS:XaSOS URUR 4X#US 9Ulg) z5Callback for mouse button press in zoom to rect mode.Nrrrqr _colorbarrinout) directionstart_xyr.rcbar)rtrarergrlrmrr:r drag_zoomrrrerr[)rJrr.id_zoom parent_axrs r4rNavigationToolbar2.press_zoom s LL!1!1;3D3D E E77?eggo 11%1G ++)) !4>>3 G 9k * *&&22DD..#lla/dUgguww'dd)Lr6cHURRnURRSn[R"X!R UR //URRURR5uupEupgURnURRS:XaSnOURRS:XaSnUS:XaURRupWOUS:XaURRupFURXXVU5 g)z#Callback for dragging in zoom mode.r horizontalrlverticalrmN)r[rr.rcliprlrmr#minrrur intervaly intervalxrg) rJrrr2rerfx2y2rus r4rNavigationToolbar2.drag_zoom3 s??++ __ ! !! $WW ) *BGGKKF(2ii ??  < /C __ ! !Z /C #:WW&&FB CZWW&&FB U3r6c^URcgURRURR5 UR 5 URR up#UR nURRS:XaSnOURRS:XaSn[URU- 5S:aUS:wd"[URU- 5S:a(US:wa"URR5 SUlg[URR5Hunm[U4SjURRSU55n[U4SjURRSU55nTRX#URUR4URR XFU5 M URR5 SUlUR#5 g) z7Callback for mouse button release in zoom to rect mode.Nrrlrrmc3d># UH%nTR5RTU5v M' g7fr)get_shared_x_axesjoinedrOprevr2s r4rP2NavigationToolbar2.release_zoom..c 1>$# UH%nTR5RTU5v M' g7fr)get_shared_y_axesrrs r4rPre rr)r[r:rrrjrrurabsrlrmr@ enumerater.r_set_view_from_bboxrr) rJrstart_xstart_yrurtwinxtwinyr2s @r4rNavigationToolbar2.release_zoomF s ?? "  ""4??#6#67  ??33ii ??  < /C __ ! !Z /C7" #a 'C3JUWWw&'!+s KK ! ! #"DO t334EAr>$(OO$8$8!$<>>E>$(OO$8$8!$<>>E  " "577EGG4))3u >5  r6c jURR[URRR Vs0sHPnXR 5URS5R5UR5R544_MR sn55 UR5 gs snf)z9Push the current view limits and position onto the stack.TN) rQpushr r:rr. _get_view get_positionrtr]r1s r4rNavigationToolbar2.push_currento s    ;;--22 43R llnt,335(//13443 4 5 6   " 4sAB0 cUR5nUcg[UR55nUH@ununupVURU5 UR US5 UR US5 MB UR R 5 g)zQ Update the viewlim and position from the view and position stack for each Axes. Noriginalactive)rQrsrY _set_view _set_positionr:r@)rJnav_inforYr2viewpos_orig pos_actives r4rmNavigationToolbar2._update_viewz s ??$   X^^%&27 .B.- LL    Xz 2   Z 2 38 r6c^^^[TS5(a9TRRRRR 5 gSSKJn [R"SS05 [TR5RU"SS9S5mSSS5 TRS 5 TRRnURS S 9 [R"TRRU5TlTRR!S U4S j5mUU4SjnURR!S U5 TR 5 TR$!,(df  N=f)N subplot_toolrrrr)r)figsizezSubplot configuration toolg?)toprc$>TR5$r)r))ers r4r:7NavigationToolbar2.configure_subplots.. s W__%6r6c@>TRRT5 T?gr)r:rr)rrrJs r4on_tool_fig_close@NavigationToolbar2.configure_subplots..on_tool_fig_close s KK & &s +!r6)rrrr:rrrrr rc_contextr&rrsubplots_adjustr SubplotToolr)rJr8rtool_figr rrs` @@r4rL%NavigationToolbar2.configure_subplots s 4 ( (    $ $ + + 3 3 8 8 : , ^^Y/ 04;;'33F64JBOG1  !=>>>((  S )#// 0B0BHMkk%% 68 " ##M3DE    1 0s ,*E## E1c[e)a. Save the current figure. Backend implementations may choose to return the absolute path of the saved file, if any, as a string. If no file is created then `None` is returned. If the backend does not implement this functionality then `NavigationToolbar2.UNKNOWN_SAVED_STATUS` is returned. Returns ------- str or `NavigationToolbar2.UNKNOWN_SAVED_STATUS` or `None` The filepath of the saved figure. Returns `None` if figure is not saved. Returns `NavigationToolbar2.UNKNOWN_SAVED_STATUS` when the backend does not provide the information. rYrns r4rNavigationToolbar2.save_figure s *"!r6cXURR5 UR5 g)zReset the Axes stack.N)rQclearr]rs r4rNavigationToolbar2.update s    "r6cg)z*Enable or disable the back/forward button.NrNrs r4r]&NavigationToolbar2.set_history_buttons rSr6) r|rYrVrWrTrQrZr[r:r\rN))rBrCrDrErF toolitemsobjectUNKNOWN_SAVED_STATUSrDr`rgrjrrrGrrr staticmethodrrXrUrrrrrrrrrrrrrrmrLrrr]rGrNr6r4rArA sL I"8#&= %   6"**> )3j:$*&78H9(   :;(JKIL44&'R # $!.".# 9r6rAcX\rSrSrSrSrSrSrSSjrSr Sr S r S r S r S rS rg)ToolContainerBasei z Base class for all tool containers, e.g. toolbars. Attributes ---------- toolmanager : `.ToolManager` The tools with which this `ToolContainer` wants to communicate. z.pngcl^UTlURSU4Sj5 URSU4Sj5 g)Ntool_message_eventc:>TRUR5$r)r`r#rrJs r4r:,ToolContainerBase.__init__.. s$**5==9r6tool_removed_eventcN>TRURR5$r)remove_toolitemtoolror s r4r:r! s$..uzz?r6)rtoolmanager_connect)rJrs` r4rDToolContainerBase.__init__ s6&'' 9 ; '' ? Ar6cxURURRURR5 g)zK Capture the 'tool_trigger_[name]' This only gets used for toggled tools. N)toggle_toolitemr%rotoggledrys r4_tool_toggled_cbk#ToolContainerBase._tool_toggled_cbk s& UZZ__ejj.@.@Ar6cURRU5nURU5n[USS5SLnUR UR X#XAR U5 U(abURRSUR -UR5 UR(aURUR S5 ggg)a Add a tool to this container. Parameters ---------- tool : tool_like The tool to add, see `.ToolManager.get_tool`. group : str The name of the group to add this tool to. position : int, default: -1 The position within the group to place this tool. r*Nztool_trigger_%sT) rget_tool_get_image_filenamer add_toolitemror3r&r+r*r))rJr%grouppositionrtoggles r4add_toolToolContainerBase.add_tool s((.((.y$/t; $))U!1!16 ;     0 01BTYY1N151G1G I||$$TYY5 r6cUR(dg[RRUR5(a URnOS[ US05;a [ S5e[ U5RH+nS[U5;dM[R"U5n O [ S5e[[R"U5R UR- 5nX"UR"-4HHn[RR%U5(dM)[RR'U5s $ URURUR"-[(R*"SUR5[(R*"SURUR"-54Hln[RR%U5(dM)[,R."SS UR<S 3S 9 [RR'U5s $ g![[4a [ S5Sef=f) zResolve a tool icon's filename.NrrzDIf 'tool.image' is an instance variable, it must be an absolute pathz:Failed to locate source file where 'tool.image' is definedz1Failed to find parent class defining 'tool.image'imagesrz Loading icon z from the current directory or from Matplotlib's image directory. This behavior is deprecated since %(since)s and will be removed in %(removal)s; Tool.image should be set to a path relative to the Tool's source file, or to an absolute path.r")rrr\isabsrrr&__mro__varsrqgetfileOSError TypeErrorr9pathlibrr_icon_extensionisfileabspathr _get_data_pathr r$)rJr%rrsrcfnames r4r/%ToolContainerBase._get_image_filename szz 77== $ $zzH'$ B77 "?@@Dz))d3i'T%ooc2 *!!TUU7<<,33djj@AH!d.B.B#BCHww~~h''wwx00D JJ JJ-- -  4:: 6  4::8L8L+L M  E ww~~e$$$$]4::.A4$45 wwu-- $Y/T(*IJOSTTs H..I c6URRXS9 g)zt Trigger the tool. Parameters ---------- name : str Name (id) of the tool triggered from within the container. )senderN)r trigger_toolrJros r4rHToolContainerBase.trigger_tool% s %%d%8r6c[e)a+ A hook to add a toolitem to the container. This hook must be implemented in each backend and contains the backend-specific code to add an element to the toolbar. .. warning:: This is part of the backend implementation and should not be called by end-users. They should instead call `.ToolContainerBase.add_tool`. The callback associated with the button click event must be *exactly* ``self.trigger_tool(name)``. Parameters ---------- name : str Name of the tool to add, this gets used as the tool's ID and as the default label of the buttons. group : str Name of the group that this tool belongs to. position : int Position of the tool within its group, if -1 it goes at the end. image : str Filename of the image for the button or `None`. description : str Description of the tool, used for the tooltips. toggle : bool * `True` : The button is a toggle (change the pressed/unpressed state between consecutive clicks). * `False` : The button is a normal button (returns to unpressed state after release). rY)rJror1r2rr3r3s r4r0ToolContainerBase.add_toolitem0 s D"!r6c[e)a A hook to toggle a toolitem without firing an event. This hook must be implemented in each backend and contains the backend-specific code to silently toggle a toolbar element. .. warning:: This is part of the backend implementation and should not be called by end-users. They should instead call `.ToolManager.trigger_tool` or `.ToolContainerBase.trigger_tool` (which are equivalent). Parameters ---------- name : str Id of the tool to toggle. toggled : bool Whether to set this tool as toggled or not. rY)rJror*s r4r)!ToolContainerBase.toggle_toolitemT s ("!r6c[e)a{ A hook to remove a toolitem from the container. This hook must be implemented in each backend and contains the backend-specific code to remove an element from the toolbar; it is called when `.ToolManager` emits a ``tool_removed_event``. Because some tools are present only on the `.ToolManager` but not on the `ToolContainer`, this method must be a no-op when called on a tool absent from the container. .. warning:: This is part of the backend implementation and should not be called by end-users. They should instead call `.ToolManager.remove_tool`. Parameters ---------- name : str Name of the tool to remove. rYrIs r4r$!ToolContainerBase.remove_toolitemj s ,"!r6c[e)zT Display a message on the toolbar. Parameters ---------- s : str Message text. rYrUs r4r`ToolContainerBase.set_message s "!r6)rN)r)rBrCrDrErFr?rDr+r4r/rHr0r)r$r`rGrNr6r4rr sDO AB62%.N 9""H","0 "r6rc|\rSrSrSrSr\rSr\ S5r \ S5r \ S5r \ SS.Sj5r \S 5rS rg) _Backendi unknownNcdSSKJn URSU5nU"U0UD6nURX5$)z%Create a new figure manager instance.rr FigureClass)rrr&new_figure_manager_given_figure)rrr8r9rfig_clsrs r4new_figure_manager_Backend.new_figure_manager s7 -**]F3t&v&223<-N-N N J((,=,I,II  "n&6&6nn&G((*'7 !r6rc[R"5nU(dgUHnUR5 M URcgUcS[[RRS5SS5n[US5nU(+=(a [5(+nU(aUR5 gg![a*n[R "[ U55 SnAMSnAff=f)z Show all figures. `show` blocks by calling `mainloop` if *block* is ``True``, or if it is ``None`` and we are not in `interactive` mode and if IPython's ``%matplotlib`` integration has not been activated. Nrrr)rrrrr rr9mainlooprr r r rrrs r4r _Backend.show s++- G -  <<   ="#++//2E"FPTUK#K=M%%>n.>*>E  LLN # -""3s8,, -sB55 C)?C$$C)c ^SH5n[[RTRU[ TU55 M7 "U4SjS[ 5n[[RTRSU5 T$)N)backend_versionr< FigureManagerrZrXrarc">\rSrSrU4SjrSrg)_Backend.export..Showi c$>TR5$r)rd)rJrs r4rd&_Backend.export..Show.mainloop s||~%r6rNN)rBrCrDrErdrGrsr4Showrj s  & &r6rm)setattrr r rCrShowBase)rrorms` r4export_Backend.export s] D CKK/wsD7I J  &8 &  CNN+VT: r6rN)rBrCrDrErgr<rrhrdrrZrXrarrrprGrNr6r4rTrT s OL&M H ==99 + +<r6rTc"\rSrSrSrSSjrSrg)roi zq Simple base class to generate a ``show()`` function in backends. Subclass must override ``mainloop()`` method. Nc URUS9$)Nr)r)rJrs r4__call__ShowBase.__call__ syyuy%%r6rNr)rBrCrDrErFrtrGrNr6r4roro s  &r6rorrw)_rF collectionsr contextlibrrrenumrrrtr:rqrrloggingrr>rrr rrr numpyr matplotlibrr r r r r rrrrrrrmatplotlib._pylab_helpersrmatplotlib.backend_managersrmatplotlib.cbookrmatplotlib.layout_enginermatplotlib.pathrmatplotlib.texmanagerrmatplotlib.transformsrmatplotlib._enumsrr getLoggerrBrzr0r/r5r>r@r#rr8rBrGrKrNrarkr~rrrrrrrrrrrrrcursorsr9r6rArrTrorNr6r4rsB6#==   %@@@@*3(< ,*1" $ - . %  &    % & % & " , , - , , , * , - , - , - -$-& `+`+FH=H=V ZZz8!!6<%<(777E7t'i)i)X.%.%b"}"L!"AJ<@$ ?6.6.rJ J ZJ8Z& i L L ^ -- =C =r9r9jH"H"VeeP&x&r6