o h9@sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZzddlmZWneycddlmZYnwddlZddlmZmZGdddZdd Zd d ZGd d d ZddZGdddZ GdddZ!Gddde"Z#ej$dddZ%ddZ&ddZ'ddZ(dd Z)dd#d$Z*dd%d&Z+d'd(Z,dd*d+Z-d,d-Z.e,fd.d/Z/Gd0d1d1Z0dd2d3Z1ej2d"fd4d5Z3Gd6d7d7Z4Gd8d9d9Z5d:d;Z6dd?Z8d"d@dAdBZ9ddDdEZ:dFdGdHdIdJZ;dKdLe;<DZ=dMdNZ>dOdPZ?dQdRZ@dSdTZAdUdVZBddXdYZCdZd[ZDd\d]ZEd^d_ZFd`daeDeDeEeFdbZGdcddZHdedfZIdgdhZJdidjZKddkdlZLejMdmdnZNejOePeQdodpfdqdrZRdsdtZSdudvZTdwdxZUdydzZVd{d|ZWejMd}d~ZXGdddejYjZZ[ddZ\ddZ]ddZ^ddZ_ddZ`ddZaddZbddZcddZdejedddZfddZgddZhddZiddZjddZkddZlddZmdS)z A collection of utility functions and classes. Originally, many (but not all) were from the Python Cookbook -- hence the name cbook. N)Path)VisibleDeprecationWarning)_api_c_internal_utilsc@s,eZdZdZddZeddZddZdS) _ExceptionInfoa A class to carry exception information around. This is used to store and later raise exceptions. It's an alternative to directly storing Exception instances that circumvents traceback-related issues: caching tracebacks can keep user's objects in local namespaces alive indefinitely, which can lead to very surprising memory issues for users and result in incorrect tracebacks. cGs||_||_dSN_cls_args)selfclsargsrd/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/matplotlib/cbook.py__init__. z_ExceptionInfo.__init__cCs|t|g|jRSr)typer )r excrrrfrom_exception2z_ExceptionInfo.from_exceptioncCs |j|jSrrr rrr to_exception6s z_ExceptionInfo.to_exceptionN)__name__ __module__ __qualname____doc__r classmethodrrrrrrr#s    rcCs&tjdptjdptjdptjd}|r!|jr!dStjd}|rE|jdkr:dd lm}|r:d S|jd krE| rEd Stjd }|rS| rSd Stjd}|r}|j j |j j j h}tD]}|r{|j|vrvdS|j}|snqj~tjd}|r|rdStsdSdS)a/ Return the interactive framework whose event loop is currently running, if any, or "headless" if no event loop can be started, or None. Returns ------- Optional[str] One of the following values: "qt", "gtk3", "gtk4", "wx", "tk", "macosx", "headless", ``None``. zPyQt6.QtWidgetszPySide6.QtWidgetszPyQt5.QtWidgetszPySide2.QtWidgetsqtzgi.repository.Gtkr)GLibgtk4gtk3wxtkintertkzmatplotlib.backends._macosxmacosxheadlessN)sysmodulesget QApplicationinstance MAJOR_VERSION gi.repositoryr main_depth main_levelGetAppmainloop__code__Misc_current_framesvaluesf_codef_backevent_loop_is_runningrdisplay_is_valid) QtWidgetsGtkrr#r$codesframer&rrr"_get_running_interactive_framework:sJ             r?cCstdvr|tdS)N)r'N)r? traceback print_exc)rrrr_exception_printerls  rBc@s0eZdZdZddZddZddZdd Zd S) _StrongRefzU Wrapper similar to a weakref, but keeping a strong reference to the object. cC ||_dSr_obj)r objrrrrx z_StrongRef.__init__cCs|jSrrErrrr__call__{sz_StrongRef.__call__cCst|to |j|jkSr) isinstancerCrF)r otherrrr__eq__~sz_StrongRef.__eq__cC t|jSr)hashrFrrrr__hash__rHz_StrongRef.__hash__N)rrrrrrIrLrOrrrrrCss  rCcCs*zt||WStyt|YSw)zQ Return a `WeakMethod` wrapping *func* if possible, else a `_StrongRef`. )weakref WeakMethod TypeErrorrC)funccallbackrrr_weak_or_strong_refs   rUc@8eZdZdZddZddZddZdd Zd d Zd S) _UnhashDicta A minimal dict-like class that also supports unhashable keys, storing them in a list of key-value pairs. This class only implements the interface needed for `CallbackRegistry`, and tries to minimize the overhead for the hashable case. cCs&i|_g|_|D]\}}|||<qdSr_dict_pairs)r pairskvrrrrs   z_UnhashDict.__init__cCslz||j|<WdSty5t|jD]\}\}}||kr)||f|j|<YdSq|j||fYdSwr)rYrR enumeraterZappend)r keyvalueir\r]rrr __setitem__s z_UnhashDict.__setitem__cCsHz|j|WStyYnw|jD] \}}||kr|Sqt|r)rYrRrZKeyError)r r`r\r]rrr __getitem__s  z_UnhashDict.__getitem__cGsxz||jvr |j|WSWn#ty1t|jD]\}\}}||kr.|j|=|YSqYnw|r8|dSt|Nr)rYpoprRr^rZrd)r r`r rbr\r]rrrrgs   z_UnhashDict.popccs(|jEdH|jD]\}}|Vq dSrrX)r r\r]rrr__iter__s  z_UnhashDict.__iter__N) rrrrrrcrergrhrrrrrWs  rWc@sveZdZdZefddddZddZdd Zd d Zd d Z e j dddZ ddZ ddZejddddZdS)CallbackRegistrya Handle registering, processing, blocking, and disconnecting for a set of signals and callbacks: >>> def oneat(x): ... print('eat', x) >>> def ondrink(x): ... print('drink', x) >>> from matplotlib.cbook import CallbackRegistry >>> callbacks = CallbackRegistry() >>> id_eat = callbacks.connect('eat', oneat) >>> id_drink = callbacks.connect('drink', ondrink) >>> callbacks.process('drink', 123) drink 123 >>> callbacks.process('eat', 456) eat 456 >>> callbacks.process('be merry', 456) # nothing will be called >>> callbacks.disconnect(id_eat) >>> callbacks.process('eat', 456) # nothing will be called >>> with callbacks.blocked(signal='drink'): ... callbacks.process('drink', 123) # nothing will be called >>> callbacks.process('drink', 123) drink 123 In practice, one should always disconnect all callbacks when they are no longer needed to avoid dangling references (and thus memory leaks). However, real code in Matplotlib rarely does so, and due to its design, it is rather difficult to place this kind of code. To get around this, and prevent this class of memory leaks, we instead store weak references to bound methods only, so when the destination object needs to die, the CallbackRegistry won't keep it alive. Parameters ---------- exception_handler : callable, optional If not None, *exception_handler* must be a function that takes an `Exception` as single parameter. It gets called with any `Exception` raised by the callbacks during `CallbackRegistry.process`, and may either re-raise the exception or handle it in another manner. The default handler prints the exception (with `traceback.print_exc`) if an interactive event loop is running; it re-raises the exception if no interactive event loop is running. signals : list, optional If not None, *signals* is a list of signals that this registry handles: attempting to `process` or to `connect` to a signal not in the list throws a `ValueError`. The default, None, does not restrict the handled signals. N)signalscCsB|durdnt||_||_i|_t|_tg|_t |_ dSr) list_signalsexception_handler callbacks itertoolscount_cid_genrW _func_cid_mapset _pickled_cids)r rmrjrrrrs    zCallbackRegistry.__init__cs2itfddjDdtjdS)Ncs(i|]\}}|fdd|DqS)cs"i|] \}}|jvr||qSr)rt).0cidproxyrrr s z..items)rusdrrrrxsz1CallbackRegistry.__getstate__..)rnrrrq)varsrnrznextrqrrrr __getstate__ s zCallbackRegistry.__getstate__cs\|d}t|fddjD_tddjD_t|_ dS)Nrqcs*i|]\}fdd|DqS)c s&i|]\}}|t|tjqSr)rU functoolspartial _remove_proxy)rurvrS)r{r rrrxsz..ry)rur|r)r{rrxs z1CallbackRegistry.__setstate__..css2|]\}}|D] \}}||f|fVq qdSrry)rur{r|rvrwrrr s  z0CallbackRegistry.__setstate__..) rgr}updaternrzrWrrrorprq)r state cid_countrrr __setstate__s   zCallbackRegistry.__setstate__cCs|jdur tj|j|dt|t|j|}z|j||fWSty?t |j }|j||f<||j |i|<|YSw)z?Register *func* to be called when signal *signal* is generated.Nsignal) rlr check_in_listrUrrrrrrdr~rqrn setdefault)r rrSrwrvrrrconnect%s  zCallbackRegistry.connectcCs|||}|j||S)z{ Like `.connect`, but the callback is kept when pickling/unpickling. Currently internal-use only. )rrtadd)r rrSrvrrr_connect_picklable1s  z#CallbackRegistry._connect_picklable)_is_finalizingcCsd|rdS|j||fd}|dur|j||=|j|ndSt|j|dkr0|j|=dSdSrf)rrrgrnrtdiscardlen)r rrwrrvrrrr=s  zCallbackRegistry._remove_proxycCs|j||jD]\}}|j||f|krnq dS|j|||ks&J|j||=|j||ft|j|dkrC|j|=dSdS)z Disconnect the callback registered with callback id *cid*. No error is raised if such a callback does not exist. Nr)rtrrrrnrgr)r rvrrwrrr disconnectJs   zCallbackRegistry.disconnectc Os|jdur tj|j|dt|j|iD]1}|}|durIz ||i|WqtyH}z|jdur=||nWYd}~qd}~wwqdS)z Process signal *s*. All of the functions registered to receive callbacks on *s* will be called with ``*args`` and ``**kwargs``. Nr) rlrrrkrnr*r6 Exceptionrm)r r{r kwargsrefrSrrrrprocess\s    zCallbackRegistry.processrc#sJ|jzdur i|_n fddD|_dVW|_dS|_w)aV Block callback signals from being processed. A context manager to temporarily block/disable callback signals from being processed by the registered listeners. Parameters ---------- signal : str, optional The callback signal to block. The default is to block all signals. Ncsi|] }|kr||qSrrrur\origrrrrxsz,CallbackRegistry.blocked..)rn)r rrrrblockedrs zCallbackRegistry.blocked)rrrrrBrrrrrr( is_finalizingrrr contextlibcontextmanagerrrrrrris<      ric@s"eZdZdZdddZddZdS) silent_lista A list with a short ``repr()``. This is meant to be used for a homogeneous list of artists, so that they don't cause long, meaningless output. Instead of :: [, , ] one will get :: If ``self.type`` is None, the type name is obtained from the first item in the list (if any). NcCs ||_|dur||dSdSr)rextend)r rseqrrrrszsilent_list.__init__cCsN|jdus t|dkr%|jdur|jnt|dj}dt|d|dSdS)Nrz z)rrr)r tprrr__repr__szsilent_list.__repr__r)rrrrrrrrrrrs  r) warning_clscGsH|}|D]}||d}|dur!|dur|}qtd|d|q|S)N"z"" keyword argument will be ignored)rgr warn_external) local_varrrkeysoutr` kwarg_valrrr_local_over_kwdicts rcCsXt|dkr*|d|dkrdkr*n|S|dd}dD] \}}|||}q|S)zi Remove latex formatting from mathtext. Only handles fully math and fully non-math strings. r$) )z\timesx)z \mathdefault)z\rmr)z\calr)z\ttr)z\itr)\r){r)}r)rreplace)r{texplainrrr strip_maths *  rcCsd} |d|}|d|}|dkr#|dkr|n|d|}|Sd|kr-|kr7nn|d|S|d|d}|dkrKtd|d|d}q) z+Strip everything from the first unquoted #.rTr#NrzMissing closing quote in: zM. If you need a double-quote inside a string, use escaping: e.g. "the " char")findstrip ValueError)r{pos quote_poshash_poswithout_commentclosing_quote_posrrr_strip_comments    rcCstt|ddS)zDReturn whether *obj* looks like a file object with a *write* method.writeN)callablegetattrrGrrris_writable_file_likesrcCs&z|dWdStyYdSw)zf Return whether the given writable file-like object requires Unicode to be written to it. TF)rrRrrrrfile_requires_unicodes   rrFcCst|tjr t|}t|tr6|drt||}n|dr,ddl}| ||}nt|||d}d}nt |dr@|}d}nt d |rJ||fS|S) a^ Convert a path to an open file handle or pass-through a file-like object. Consider using `open_file_cm` instead, as it allows one to properly close newly created file objects more easily. Parameters ---------- fname : str or path-like or file-like If `str` or `os.PathLike`, the file is opened using the flags specified by *flag* and *encoding*. If a file-like object, it is passed through. flag : str, default: 'r' Passed as the *mode* argument to `open` when *fname* is `str` or `os.PathLike`; ignored if *fname* is file-like. return_opened : bool, default: False If True, return both the file object and a boolean indicating whether this was a new file (that the caller needs to close). If False, return only the new file. encoding : str or None, default: None Passed as the *mode* argument to `open` when *fname* is `str` or `os.PathLike`; ignored if *fname* is file-like. Returns ------- fh : file-like opened : bool *opened* is only returned if *return_opened* is True. .gzz.bz2rN)encodingTseekFz'fname must be a PathLike or file handle) rJosPathLikefspathstrendswithgzipopenbz2BZ2Filehasattrr)fnameflag return_openedrfhropenedrrr to_filehandles"      rcCs$t||d|\}}|r |St|S)z8Pass through file objects and context-manage path-likes.T)rr nullcontext) path_or_filemoderrrrrr open_file_cm.srcCst|tp t| S)z;Return whether the given object is a scalar or string like.)rJrnpiterablevalrrris_scalar_or_string4rrTcCs`td|}|r,|j}|dkrt|S|dvrt|S|dvr'|dS|dSt|S)a Return a sample data file. *fname* is a path relative to the :file:`mpl-data/sample_data` directory. If *asfileobj* is `True` return a file object, otherwise just a file path. Sample data files are stored in the 'mpl-data/sample_data' directory within the Matplotlib package. If the filename ends in .gz, the file is implicitly ungzipped. If the filename ends with .npy or .npz, and *asfileobj* is `True`, the file is loaded with `numpy.load`. sample_datar)z.npyz.npz)z.csvz.xrcz.txtrrb)_get_data_pathsuffixlowerrrrloadr)r asfileobjpathrrrrget_sample_data9s      rcGsttg|RS)z Return the `pathlib.Path` to a resource file provided by Matplotlib. ``*args`` specify a path relative to the base data path. )r matplotlib get_data_path)r rrrrUsrccs8|D]}||s |dur|Vqt||EdHqdS)a Return a generator of flattened nested containers. For example: >>> from matplotlib.cbook import flatten >>> l = (('John', ['Hunter']), (1, 23), [[([42, (5, 23)], )]]) >>> print(list(flatten(l))) ['John', 'Hunter', 1, 23, 42, 5, 23] By: Composite of Holger Krekel and Luther Blissett From: https://code.activestate.com/recipes/121294-simple-generator-for-flattening-nested-containers/ and Recipe 1.12 in cookbook N)flatten)rscalarpitemrrrr^s rc@sXeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dS)_Stackzb Stack of elements with a movable cursor. Mimics home/back/forward in a web browser. cCsd|_g|_dS)Nr_pos _elementsrrrrr{rz_Stack.__init__cCsd|_g|_dS)zEmpty the stack.rNrrrrrclears z _Stack.clearcCs|jr |j|jSdS)z$Return the current element, or None.N)rrrrrrrIrz_Stack.__call__cCrMr)rrrrrr__len__rHz_Stack.__len__cCs |j|Sr)r)r indrrrrerHz_Stack.__getitem__cCs"t|jdt|jd|_|S)z9Move the position forward and return the current element.r)minrrrrrrrforwardsz_Stack.forwardcCst|jdd|_|S)z6Move the position back and return the current element.rr)maxrrrrrbacksz _Stack.backcCs*|g|j|jdd<t|jd|_|S)zx Push *o* to the stack after the current position, and return *o*. Discard all later elements. rN)rrr)r orrrpushsz _Stack.pushcCs|jr ||jdSdS)zk Push the first element onto the top of the stack. The first element is returned. rN)rrrrrrhomesz _Stack.homeN) rrrrrrrIrrerrrrrrrrrts rcCsjtj|d|d}|jjs|j|d|jd}ztjjt ||dd}W|St y4|YSw)NT)subokcopy)inplaceNF)r) rarraydtypeisnativebyteswapview newbyteorderma masked_whereisfiniterR)rrxmrrrsafe_masked_invalids rcsXddlfddfddD]}d|d||igqdS) a Print loops of cyclic references in the given *objects*. It is often useful to pass in ``gc.garbage`` to find the cycles that are preventing some objects from being garbage collected. Parameters ---------- objects A list of objects to find cycles in. outstream The stream for output. show_progress : bool If True, print the number of objects reached as they are found. rNcst|D]j\}}||dt|}dt|t|trG|D]!\}}||ur7d|dn||urEd|nq$n"t|trWd||nt|t rbdnt |dqd dS) Nrz %s -- []z[key] = z[%d]z ( tuple )z ->  ) r^rrrrJdictrzrkindextuplerepr)rrbstepr~r`r) outstreamrr print_paths(     z print_cycles..print_pathcsr dt|d|t|<|}|D]&}||ur#|q|us-t|tjr.qt||vr>|||||gqdS)Nz%d )rrid get_referentsrJtypes FrameType)rGstartall current_path referentsreferentgcobjectsrrrecurse show_progressrrr)s    zprint_cycles..recursez Examining: r)r'r)r(rr*rGrr&r print_cycless r+c@sZeZdZdZdddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ dS)Groupera# A disjoint-set data structure. Objects can be joined using :meth:`join`, tested for connectedness using :meth:`joined`, and all disjoint sets can be retrieved by using the object as an iterator. The objects being joined must be hashable and weak-referenceable. Examples -------- >>> from matplotlib.cbook import Grouper >>> class Foo: ... def __init__(self, s): ... self.s = s ... def __repr__(self): ... return self.s ... >>> a, b, c, d, e, f = [Foo(x) for x in 'abcdef'] >>> grp = Grouper() >>> grp.join(a, b) >>> grp.join(b, c) >>> grp.join(d, e) >>> list(grp) [[a, b, c], [d, e]] >>> grp.joined(a, b) True >>> grp.joined(a, c) True >>> grp.joined(a, d) False rcCsTtdd|D|_t|_|D]}||jvr!t|j|j|<qt|j|_dS)NcSsi|] }|t|gqSrrPWeakSetrurrrrrx"z$Grouper.__init__..)rPWeakKeyDictionary_mapping _orderingr _next_order)r initrrrrr s   zGrouper.__init__cCs,it|dd|jDi|jdS)NcSsi|] \}}|t|qSr)rsrur\r]rrrrx-r0z(Grouper.__getstate__..)r2r3)r}r2rzr3rrrrr)s zGrouper.__getstate__cCs<t||tdd|jD|_t|j|_dS)NcSsi|] \}}|t|qSrr-r6rrrrx5sz(Grouper.__setstate__..)r}rrPr1r2rzr3)r rrrrr1s zGrouper.__setstate__cC ||jvSr)r2r rrrr __contains__8rHzGrouper.__contains__c Gs|j}z||}Wn ty)t|g}||<|j|j|<|jd7_Ynw|D]H}z||}Wn tyTt|g}||<|j|j|<|jd7_Ynw||urtt|t|krf||}}|||D]}|||<qmq,dS)zY Join given arguments into the same set. Accepts one or more arguments. rN)r2rdrPr.r4r3rr)r ar mappingset_aargset_belemrrrjoin;s0         z Grouper.joincCs|j|t|j|uS)z7Return whether *a* and *b* are members of the same set.)r2r*objectr r:brrrjoinedTszGrouper.joinedcCs(|j||h||j|ddS)z>Remove *a* from the grouper, doing nothing if it is not there.N)r2rgremover3r r:rrrrEXszGrouper.removeccs:dd|jD}|D] }t||jjdVqdS)z Iterate over each of the disjoint sets as a list. The iterator is invalid if interleaved with calls to join(). cSsi|]}t||qSr)r)rugrouprrrrxcz$Grouper.__iter__..r`N)r2r6sortedr3re)r unique_groupsrGrrrrh]s  zGrouper.__iter__cCs |j||g}t||jjdS)z:Return all of the items joined with *a*, including itself.rI)r2r*rJr3)r r:siblingsrrr get_siblingsgszGrouper.get_siblingsN)r) rrrrrrrr9r@rDrErhrMrrrrr,s !  r,c@rV) GrouperViewz!Immutable view over a `.Grouper`.cCrDr_grouper)r grouperrrrrp zGrouperView.__init__cCr7rrOr8rrrr9qrRzGrouperView.__contains__cCrMr)iterrPrrrrrhrrRzGrouperView.__iter__cCs|j||S)zI Return whether *a* and *b* are members of the same set. )rPrDrBrrrrDtszGrouperView.joinedcCs |j|S)zL Return all of the items joined with *a*, including itself. )rPrMrFrrrrMzs zGrouperView.get_siblingsN) rrrrrr9rhrDrMrrrrrNms rNcst|t|df}tt||tt|d|dtfdd|jDtf|jddS)a} Resample an array with ``steps - 1`` points between original point pairs. Along each column of *a*, ``(steps - 1)`` points are introduced between each original values; the values are linearly interpolated. Parameters ---------- a : array, shape (n, ...) steps : int Returns ------- array shape ``((n - 1) * steps + 1, ...)`` rrcsg|] }t|qSr)rinterp)rufprxprr r0z/simple_linear_interpolation..N)reshaperrarange column_stackTshape)r:stepsfpsrrVrsimple_linear_interpolations r`c Gst|sdSt|drtdt|d}g}dgt|}t|D]3\}}t|tsQt|rQt||krQd||<t|tjj rL|j dkrKtdnt |}| |q#g}t|D]A\}}||r|j dkrkq]t|tjj r| tj ||j}n|}zt|}t|tjr| |Wq]tyYq]wq]t|rtj|}|d} t| |krt|D]\}}||r|| ||<qt|D]\}}||rt|tjj r|||<q|S)ak Find all masked and/or non-finite points in a set of arguments, and return the arguments with only the unmasked points remaining. Arguments can be in any of 5 categories: 1) 1-D masked arrays 2) 1-D ndarrays 3) ndarrays with more than one dimension 4) other non-string iterables 5) anything else The first argument must be in one of the first four categories; any argument with a length differing from that of the first argument (and hence anything in category 5) then will be passed through unchanged. Masks are obtained from all arguments of the correct length in categories 1, 2, and 4; a point is bad if masked in a masked array or if it is a nan or inf. No attempt is made to extract a mask from categories 2, 3, and 4 if `numpy.isfinite` does not yield a Boolean array. All input arguments that are not passed unchanged are returned as ndarrays after removing the points or rows corresponding to masks in any of the arguments. A vastly simpler version of this function was originally written as a helper for Axes.scatter(). rr!First argument must be a sequenceFTrMasked arrays must be 1-D)rrrr^rJrrrr MaskedArrayndimasarrayr_ getmaskarraydatarndarrayr logical_andreducenonzerofilled) r nrecsmargsseqlistrbrmasksxdmaskigoodrrrdelete_masked_pointss^                 rtc GsPt|sdSt|drtdt|d}g}dgt|}g}t|D]_\}}t|s3t||kr9||q%t|tjjrI|j dkrItdzt |}Wnt tfybtj |t d}Ynw|j dkrt |}d||<tj|r|tj|||q%t|rtj|}t|D]\}}||rtjj||d ||<q|S) ax Find all masked and/or non-finite points in a set of arguments, and return the arguments as masked arrays with a common mask. Arguments can be in any of 5 categories: 1) 1-D masked arrays 2) 1-D ndarrays 3) ndarrays with more than one dimension 4) other non-string iterables 5) anything else The first argument must be in one of the first four categories; any argument with a length differing from that of the first argument (and hence anything in category 5) then will be passed through unchanged. Masks are obtained from all arguments of the correct length in categories 1, 2, and 4; a point is bad if masked in a masked array or if it is a nan or inf. No attempt is made to extract a mask from categories 2 and 4 if `numpy.isfinite` does not yield a Boolean array. Category 3 is included to support RGB or RGBA ndarrays, which are assumed to have only valid values and which are passed through unchanged. All input arguments that are not passed unchanged are returned as masked arrays if any masked points are found, otherwise as ndarrays. rrraFrrbr Trr)rrrr^r_rJrrrcrd asanyarrayrrAr is_maskedrf logical_orrjr)r rmrnrorprbrrrrrr_combine_maskss>       rz)compresscsdd|D}tjg||R}|dt|}|t|d}|rAtj||r6fdd|D}|Sfdd|D}|Sdd|D}|S)aw Broadcast inputs, combining all masked arrays. Parameters ---------- *args : array-like The inputs to broadcast. compress : bool, default: False Whether to compress the masked arrays. If False, the masked values are replaced by NaNs. Returns ------- list of array-like The broadcasted and masked inputs. cSs g|] }t|tjjr|jqSr)rJrrrcrrrrrrrX9s z)_broadcast_with_masks..Ncs g|] }tjj|dqS)rv)rrr compressedrrvrrrXCscs*g|]}tjj|tdtjqS))rrr )rrrfloatrlnanravelrrvrrrXFs"cSsg|]}t|qSr)rrrrrrrXIrH)rbroadcast_arraysrryrj)r{r rpbcastinputsrrvr_broadcast_with_masks's"   r?csdddfdd}g}t|d}t|}|dur td}n t||kr*td|}tt||D]$\} \} } i} | durD| | d <|}|| t| d krt g| d <tj | d <tj | d <tj | d<tj | d<tj | d<tj | d<tj | d<tj | d<tj | d<q3tj | } | j | j} t| | d <t| gd\} }}|| | d<| dd kr|rd}|| || d|\| d<| d<t|rt|tst| |\}}nt|r| || d}||| d}ntd| | |k}t|d kst||kr || d<nt|| d<| | |k}t|d ks)t|| kr.| | d<nt|| d<t| | | dk| | | dkg| d <| ||| d<| d <| d<q3|S)aj Return a list of dictionaries of statistics used to draw a series of box and whisker plots using `~.Axes.bxp`. Parameters ---------- X : array-like Data that will be represented in the boxplots. Should have 2 or fewer dimensions. whis : float or (float, float), default: 1.5 The position of the whiskers. If a float, the lower whisker is at the lowest datum above ``Q1 - whis*(Q3-Q1)``, and the upper whisker at the highest datum below ``Q3 + whis*(Q3-Q1)``, where Q1 and Q3 are the first and third quartiles. The default value of ``whis = 1.5`` corresponds to Tukey's original definition of boxplots. If a pair of floats, they indicate the percentiles at which to draw the whiskers (e.g., (5, 95)). In particular, setting this to (0, 100) results in whiskers covering the whole range of the data. In the edge case where ``Q1 == Q3``, *whis* is automatically set to (0, 100) (cover the whole range of the data) if *autorange* is True. Beyond the whiskers, data are considered outliers and are plotted as individual points. bootstrap : int, optional Number of times the confidence intervals around the median should be bootstrapped (percentile method). labels : list of str, optional Labels for each dataset. Length must be compatible with dimensions of *X*. autorange : bool, optional (False) When `True` and the data are distributed such that the 25th and 75th percentiles are equal, ``whis`` is set to (0, 100) such that the whisker ends are at the minimum and maximum of the data. Returns ------- list of dict A list of dictionaries containing the results for each column of data. Keys of each dictionary are the following: ======== =================================== Key Value Description ======== =================================== label tick label for the boxplot mean arithmetic mean value med 50th percentile q1 first quartile (25th percentile) q3 third quartile (75th percentile) iqr interquartile range cilo lower notch around the median cihi upper notch around the median whislo end of the lower whisker whishi end of the upper whisker fliers outliers ======== =================================== Notes ----- Non-bootstrapping approach to confidence interval uses Gaussian-based asymptotic approximation: .. math:: \mathrm{med} \pm 1.57 \times \frac{\mathrm{iqr}}{\sqrt{N}} General approach from: McGill, R., Tukey, J.W., and Larsen, W.A. (1978) "Variations of Boxplots", The American Statistician, 32:12-16. cSsLt|}ddg}tjj|||fd}||}tj|ddd}t||}|S)Ng@g`X@)sizerT)axisoverwrite_input)rrrandomrandintmedian percentile)rgrM percentilesbs_indexbsDataestimateCIrrr_bootstrap_medians z(boxplot_stats.._bootstrap_mediancsh|dur||d}|d}|d}||fSt|}|d|t|}|d|t|}||fS)N)rrrgQ?)rrsqrt)rgmediqr bootstrapr notch_min notch_maxrrrr_compute_conf_intervals z-boxplot_stats.._compute_conf_intervalXNz-Dimensions of labels and X must be compatiblelabelrfliersmeanrq1q3rcilocihiwhislowhishi)2K)rdz+whis must be a float or list of percentiles)r) _reshape_2Drrorepeatrr^zipr_rrr~rrergrrrrrrrJrisrealrr concatenate)rwhisrlabels autorangerbxpstatsncols input_whisiirrstatsrrrlovalhivalwiskhiwisklorrr boxplot_statsMst O                        rsoliddasheddashdotdotted)-z--z-.:cCsi|]\}}||qSrrr6rrrrxrHrxcCstj|td}|js gSt|dd|ddk\}|d7}|}|dr-dg|}|dr8|t|tt |ddd|dddS)zv Return a list of (ind0, ind1) such that ``mask[ind0:ind1].all()`` is True and we cover all such regions. ruNrrrr) rreboolrrktolistr_rrkr)rridxrrrcontiguous_regionss  "rcCs4t|}|d|d}|dko|ddk}|S)z Return whether the string *s* contains math expressions. This is done by checking whether *s* contains an even number of non-escaped dollar signs. rz\$rr)rrp)r{ dollar_count even_dollarsrrr is_math_text6srcCs,t|drtj|ttjSt|tS)zt Convert a sequence to a float array; if input was a masked array, masked values are converted to nans. rr)rrrrer}rlr~rrrr_to_unmasked_float_arrayCs  rcCs8t|}t|drt|drt|jdkrt|S|S)z8Convert scalars to 1D arrays; pass-through arrays as is.r]rdr)_unpack_to_numpyrrr]r atleast_1drrrr _check_1dNs  rc Cst|}t|tjr:|j}t|dkrggS|jdkr't|ddkr'|gS|jdvr3dd|DSt|dt|dkrCggSg}d}|D]6}t|tsbzt |Wn t y_Ynwd}t |}t|}|dkrwt|d| | d qI|rt |d gS|S) a Use Fortran ordering to convert ndarrays and lists of iterables to lists of 1D arrays. Lists of iterables are converted by applying `numpy.asanyarray` to each of their elements. 1D ndarrays are returned in a singleton list containing them. 2D ndarrays are converted to the list of their *columns*. *name* is used to generate the error message for invalid inputs. rr)rrcSsg|]}t|dqS)r)rrYr/rrrrXwsz_reshape_2D..z must have 2 or fewer dimensionsTFr)rrJrrhr\rrdrrrSrRrwr_rY)rnameresultis_1dxindrrrr]s<         rrc Csg}t|d}|durt|dkrt|d}nggt|}t|t|kr*tdt||D]L\}}i}t|}t|} t|d|} t|| |} ||| |d<| |d<t ||d <t ||d <||d <| |d <t | |d<| |q/|S) a[ Return a list of dictionaries of data which can be used to draw a series of violin plots. See the ``Returns`` section below to view the required keys of the dictionary. Users can skip this function and pass a user-defined set of dictionaries with the same keys to `~.axes.Axes.violinplot` instead of using Matplotlib to do the calculations. See the *Returns* section below for the keys that must be present in the dictionaries. Parameters ---------- X : array-like Sample data that will be used to produce the gaussian kernel density estimates. Must have 2 or fewer dimensions. method : callable The method used to calculate the kernel density estimate for each column of data. When called via ``method(v, coords)``, it should return a vector of the values of the KDE evaluated at the values specified in coords. points : int, default: 100 Defines the number of points to evaluate each of the gaussian kernel density estimates at. quantiles : array-like, default: None Defines (if not None) a list of floats in interval [0, 1] for each column of data, which represents the quantiles that will be rendered for that column of data. Must have 2 or fewer dimensions. 1D array will be treated as a singleton list containing them. Returns ------- list of dict A list of dictionaries containing the results for each column of data. The dictionaries contain at least the following: - coords: A list of scalars containing the coordinates this particular kernel density estimate was evaluated at. - vals: A list of scalars containing the values of the kernel density estimate at each of the coordinates given in *coords*. - mean: The mean value for this column of data. - median: The median value for this column of data. - min: The minimum value for this column of data. - max: The maximum value for this column of data. - quantiles: The quantile values for this column of data. rNr quantileszLList of violinplot statistics and quantiles values must have the same lengthrvalscoordsrrrr) rrrrrrrrlinspacerrrr_) rmethodpointsrvpstatsrqrmin_valmax_val quantile_valrrrr violin_statss,5     rcGstdt|tdt|ddf}||ddddf<|ddddf|ddddf<||dddddf<|dddddf|dddddf<|S)a( Convert continuous line to pre-steps. Given a set of ``N`` points, convert to ``2N - 1`` points, which when connected linearly give a step function which changes values at the beginning of the intervals. Parameters ---------- x : array The x location of the steps. May be empty. y1, ..., yp : array y arrays to be turned into steps; all must be the same length as ``x``. Returns ------- array The x and y values converted to steps in the same order as the input; can be unpacked as ``x_out, y1_out, ..., yp_out``. If the input is length ``N``, each of these arrays will be length ``2N + 1``. For ``N=0``, the length will be 0. Examples -------- >>> x_s, y1_s, y2_s = pts_to_prestep(x, y1, y2) rrrNrzerosrrrr r^rrrpts_to_presteps ( (rcGstdt|tdt|ddf}||ddddf<|ddddf|ddddf<||dddddf<|dddddf|dddddf<|S)a# Convert continuous line to post-steps. Given a set of ``N`` points convert to ``2N + 1`` points, which when connected linearly give a step function which changes values at the end of the intervals. Parameters ---------- x : array The x location of the steps. May be empty. y1, ..., yp : array y arrays to be turned into steps; all must be the same length as ``x``. Returns ------- array The x and y values converted to steps in the same order as the input; can be unpacked as ``x_out, y1_out, ..., yp_out``. If the input is length ``N``, each of these arrays will be length ``2N + 1``. For ``N=0``, the length will be 0. Examples -------- >>> x_s, y1_s, y2_s = pts_to_poststep(x, y1, y2) rrrNrrrrrrpts_to_poststep!s ( (rcGstdt|dt|f}t|}|dd|ddd|ddddf<|ddddf<|dd|dddf<|dd|dddf<||dddddf<|dddddf|dddddf<|S)a Convert continuous line to mid-steps. Given a set of ``N`` points convert to ``2N`` points which when connected linearly give a step function which changes values at the middle of the intervals. Parameters ---------- x : array The x location of the steps. May be empty. y1, ..., yp : array y arrays to be turned into steps; all must be the same length as ``x``. Returns ------- array The x and y values converted to steps in the same order as the input; can be unpacked as ``x_out, y1_out, ..., yp_out``. If the input is length ``N``, each of these arrays will be length ``2N``. Examples -------- >>> x_s, y1_s, y2_s = pts_to_midstep(x, y1, y2) rrNrr)rrrrwrrrrpts_to_midstepEs <(rcCs||fSrr)ryrrrksr)defaultr^z steps-prez steps-postz steps-midc Csjz |j|fWStyYnwzt|}Wnttfy(Ytdwtj|jdt d|fS)a A helper function to create reasonable x values for the given *y*. This is used for plotting (x, y) if x values are not explicitly given. First try ``y.index`` (assuming *y* is a `pandas.Series`), if that fails, use ``range(len(y))``. This will be extended in the future to deal with more types of labeled data. Parameters ---------- y : float or array-like Returns ------- x, y : ndarray The x and y values to plot. rruz5Input could not be cast to an at-least-1D NumPy array) rto_numpyAttributeErrorrrrrrZr]r})rrrrindex_ofrs  rcCs>t|tjjrz|dWStyYtdwtt|S)z Return the first element in *obj*. This is a type-independent way of obtaining the first element, supporting both index access and the iterator protocol. r/matplotlib does not support generators as input)rJ collectionsabcIteratorrR RuntimeErrorr~rSrrrrsafe_first_elements   rcCsTdd}t|tjr|dSt|tjjrtd|D] }||r%|Sqt|S)a: Return the first finite element in *obj* if one is available and skip_nonfinite is True. Otherwise, return the first element. This is a method for internal use. This is a type-independent way of obtaining the first finite element, supporting both index access and the iterator protocol. c Ssb|durdSzt|WSttfyYnwzt|r$t|WSdWSty0YdSw)NFT)mathrrRrrisscalarrrrr safe_isfinites  z)_safe_first_finite..safe_isfiniterr)rJrflatiterrrrrr)rGrrrrr_safe_first_finites rcCst|tjjr t|S|S)zP Convert dictview objects to list. Other inputs are returned unchanged. )rJrr MappingViewrk)rgrrrsanitize_sequencesrc Csddlm}|dur iS|duri}nt|trt||s"t||r(t|di}dd|D}i}i}|D]#\}}|||}||vrTtd||d|d |||<|||<q9|S) aA Helper function to normalize kwarg inputs. Parameters ---------- kw : dict or None A dict of keyword arguments. None is explicitly supported and treated as an empty dict, to support functions with an optional parameter of the form ``props=None``. alias_mapping : dict or Artist subclass or Artist instance, optional A mapping between a canonical name to a list of aliases, in order of precedence from lowest to highest. If the canonical value is not in the list it is assumed to have the highest priority. If an Artist subclass or instance is passed, use its properties alias mapping. Raises ------ TypeError To match what Python raises if invalid arguments/keyword arguments are passed to a callable. r)ArtistN _alias_mapcSs i|] \}}|D]}||qqSrr)ru canonical alias_listaliasrrrrxs  z$normalize_kwargs..z Got both z and z", which are aliases of one another) matplotlib.artistrrJr issubclassrrzr*rR) kw alias_mappingr to_canonicalcanonical_to_seenretr\r]rrrrnormalize_kwargss.     rc cst|}||jd}d}d}t|D]*}z|d  WdWn1s+wYWqty?t|Yqwtd |z dVW| dS| w)af Context manager for locking a path. Usage:: with _lock_path(path): ... Another thread or process that attempts to lock the same path will wait until this context manager is exited. The lock is implemented by creating a temporary file in the parent directory, so that directory must exist and be writable. z.matplotlib-lockrg?xbNzLock error: Matplotlib failed to acquire the following lock file: {} This maybe due to another process holding this lock file. If you are sure no other Matplotlib process is running, remove this file and try again.) r with_namerrangerFileExistsErrortimesleep TimeoutErrorformatunlink)r lock_pathretries sleeptime_rrr _lock_paths*  & rzorderrIcCs |t|S)a Get the topmost artist of a list. In case of a tie, return the *last* of the tied artists, as it will be drawn on top of the others. `max` returns the first maximum in case of ties, so we need to iterate over the list in reverse order. )reversed)artists _cached_maxrrr_topmost_artist7s rcCst|to||kS)a Return whether *obj* is a string equal to string *s*. This helper solely exists to handle the case where *obj* is a numpy array, because in such cases, a naive ``obj == s`` would yield an array, which cannot be used in a boolean context. )rJrrGr{rrr _str_equalDsrcCst|to ||kS)a Return whether *obj* is a string equal, when lowercased, to string *s*. This helper solely exists to handle the case where *obj* is a numpy array, because in such cases, a naive ``obj == s`` would yield an array, which cannot be used in a boolean context. )rJrrrrrr_str_lower_equalOsrcCsPtjdd}tjddd}t|d|f||df|d|f||dffS)aZ Get the elements on the perimeter of *arr*. Parameters ---------- arr : ndarray, shape (M, N) The input array. Returns ------- ndarray, shape (2*(M - 1) + 2*(N - 1),) The elements on the perimeter of the array:: [arr[0, 0], ..., arr[0, -1], ..., arr[-1, -1], ..., arr[-1, 0], ...] Examples -------- >>> i, j = np.ogrid[:3, :4] >>> a = i*10 + j >>> a array([[ 0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23]]) >>> _array_perimeter(a) array([ 0, 1, 2, 3, 13, 23, 22, 21, 20, 10]) rr)rs_r)arrrbackwardrrr_array_perimeterZs    rcCs`g|j|}g|j|j|}||||d||<|||||<tjjj|||ddS)a Append an extra dimension containing sliding windows along *axis*. All windows are of size *size* and begin with every *step* elements. Parameters ---------- arr : ndarray, shape (N_1, ..., N_k) The input array axis : int Axis along which the windows are extracted size : int Size of the windows step : int Stride between first elements of subsequent windows. Returns ------- ndarray, shape (N_1, ..., 1 + (N_axis-size)/step, ..., N_k, size) Examples -------- >>> i, j = np.ogrid[:3, :7] >>> a = i*10 + j >>> a array([[ 0, 1, 2, 3, 4, 5, 6], [10, 11, 12, 13, 14, 15, 16], [20, 21, 22, 23, 24, 25, 26]]) >>> _unfold(a, axis=1, size=3, step=2) array([[[ 0, 1, 2], [ 2, 3, 4], [ 4, 5, 6]], [[10, 11, 12], [12, 13, 14], [14, 15, 16]], [[20, 21, 22], [22, 23, 24], [24, 25, 26]]]) rF)r]strides writeable)r]rrlib stride_tricks as_strided)rrrr new_shape new_stridesrrr_unfolds( r&cCs |dkr|dks J|jdd|dksJ|jdd|dks$Jt|dd|ddfd||}t||d|ddfd||ddddf}t|dd|d|fd||}t|dddd|fd||ddddf}tj||||fdddd||S)ad Extract perimeters of patches from *arr*. Extracted patches are of size (*rstride* + 1) x (*cstride* + 1) and share perimeters with their neighbors. The ordering of the vertices matches that returned by ``_array_perimeter``. Parameters ---------- x : ndarray, shape (N, M) Input array rstride : int Vertical (row) stride between corresponding elements of each patch cstride : int Horizontal (column) stride between corresponding elements of each patch Returns ------- ndarray, shape (N/rstride * M/cstride, 2 * (rstride + cstride)) rrNr.rr)r]r&rrrY)rrstridecstridetopbottomrightleftrrr_array_patch_perimeterss . .r.c kst}i}|D]+}t|||}||jvs||ur|||<qtt||}t|tr/|||<q|||<qz.|D] \}}t|||q9dVW|D]\}}||urZt||qLt|||qLdS|D]\}}||urut||qgt|||qgw)zR Temporarily set some attributes; restore original state at context exit. N) rAr__dict__rrJpropertyrzsetattrdelattr)rGrsentinelorigsattrrcls_origrrrr _setattr_cms0       r7c@s<eZdZddZddZddZddZd d Zd d Zd S) _OrderedSetcCst|_dSr)r OrderedDict_odrrrrrsz_OrderedSet.__init__cCr7r)r:r r`rrrr9rHz_OrderedSet.__contains__cCrMr)rSr:rrrrrhrHz_OrderedSet.__iter__cCrMr)rr:rrrrrrHz_OrderedSet.__len__cCs|j|dd|j|<dSrr:rgr;rrrrsz_OrderedSet.addcCs|j|ddSrr<r;rrrr!sz_OrderedSet.discardN) rrrrr9rhrrrrrrrr8s r8cCstj|tjdkr gdngddd}|dddf}|d }|d k}t|dD]}||td ||d||||<q)|S) zS Convert a premultiplied ARGB32 buffer to an unmultiplied RGBA8888 buffer. littlerrrr!)rrr!rrr'.Nr).rr)rtaker( byteorderrollaxisastypeint)bufrgbargbalpharrchannelrrr._premultiplied_argb32_to_unmultiplied_rgba8888)srJcCstjdkr tj|gddd}|dddf}|dddf}ntj|gddd}|ddd f}|dd df}|d krKtj||d |d d |S) zS Convert an unmultiplied RGBA8888 buffer to a premultiplied ARGB32 buffer. r=r>rr'.Nr)r!rrrrr?unsafe)rcasting)r(rArr@rmultiply)rgba8888argb32rgb24alpha8rrr._unmultiplied_rgba8888_to_premultiplied_argb32;s  rRcCs|jdd\}|jdd\}t|r8t|r8|ddg\}}|ddg\}}t||dt||dfStddtddfS)a! Return the bounds of the nonzero region of a 2D array as a pair of slices. ``buf[_get_nonzero_slices(buf)]`` is the smallest sub-rectangle in *buf* that encloses all non-zero entries in *buf*. If *buf* is fully zero, then ``(slice(0, 0), slice(0, 0))`` is returned. rr'rr)anyrkrslice)rEx_nzy_nzlrrCtrrr_get_nonzero_slicesOsrYcCs"t|tr|Sddd|DS)zAPretty-format a subprocess command for printing/logging purposes.rcss |] }tt|VqdSr)shlexquoterr)rur=rrrrdsz&_pformat_subprocess..)rJrr@)commandrrr_pformat_subprocessasr]cKs|dt|tj|fddi|}|jr=|j}t|tr"|}|j }t|tr.|}t dt|d|d||jrG|d|j|j rQ|d|j |jS) aj Run *command*, returning its stdout output if it succeeds. If it fails (exits with nonzero return code), raise an exception whose text includes the failed command and captured stdout and stderr output. Regardless of the return code, the command is logged at DEBUG level on *logger*. In case of success, the output is likewise logged. z%scapture_outputTzThe command z, failed and generated the following output: z and the following error: z stdout: %sz stderr: %s) debugr] subprocessrun returncodestdoutrJbytesdecodestderrr)r\loggerrprocrcrfrrr_check_and_log_subprocessgs.   ricCs.ztWdStytdYdSw)zS Perform OS-dependent setup when Matplotlib creates a new GUI application. rN)r-Win32_GetCurrentProcessExplicitAppUserModelIDOSError-Win32_SetCurrentProcessExplicitAppUserModelIDrrrr_setup_new_guiapps  rmcCs |d|dddpdS)z Format the number with at most the number of decimals given as precision. Remove trailing zeros and possibly the decimal point. .f0)rstrip)number precisionrrr_format_approxs rtcCsf|dkr|dkr dStt|}t|r1td|r&ttt|dndtt|SdS)z Return the number of significant digits to %g-format *value*, assuming that it is known with an error of *delta*. rr!r)absrspacingrrrfloorlog10)radeltarrr _g_sig_digitss rzcCs|r|r|S|}|dr|dd}|dr"|dd}|dr-|dd}tjdkr8|d kr8d }d d d d||}|S)z Convert a Unicode key or X keysym to a Matplotlib key name. The Unicode key is checked first; this avoids having to list most printable keysyms such as ``EuroSign``. kp_r!Npage_page)_l_rrdarwinmetacmdenterpageuppagedown)returnpriorr~) isprintabler startswithrrr(platformr*)unikeykeysymr`rrr_unikey_or_keysym_to_mplkeys$       rcs"tjfdd}j|_|S)ax Return a function that creates picklable classes inheriting from a mixin. After :: factory = _make_class_factory(FooMixin, fmt, attr_name) FooAxes = factory(Axes) ``Foo`` is a class that inherits from ``FooMixin`` and ``Axes`` and **is picklable** (picklability is what differentiates this from a plain call to `type`). Its ``__name__`` is set to ``fmt.format(Axes.__name__)`` and the base class is stored in the ``attr_name`` attribute, if not None. Moreover, the return value of ``factory`` is memoized: calls with the same ``Axes`` class always return the same subclass. csZt|r|S|Gfddd}j|_|_dur+t||S)Ncs$eZdZjZfddZdS)z:_make_class_factory..class_factory..subclscstf|fSr)_picklable_class_constructorrr attr_name base_classfmt mixin_classrr __reduce__s zE_make_class_factory..class_factory..subcls.__reduce__N)rrrrrrrrsubclssr)rr rrr1) axes_classrrrr)rr class_factorys   z*_make_class_factory..class_factory)rcacher)rrrrrrr_make_class_factorysrcCst|||}||}||S)z(Internal helper for _make_class_factory.)r__new__)rrrrfactoryr rrrr s  rcC*z t|tjdjWStyYdSw)z!Check if 'x' is a PyTorch Tensor.torchF)rJr(r)Tensorrrrrr_is_torch_array  rcCr)zCheck if 'x' is a JAX Array.jaxF)rJr(r)Arrayrrrrr _is_jax_array rrcCs.z t|tjd|WStyYdSw)z0Check if 'x' is a TensorFlow Tensor or Variable. tensorflowF)rJr(r) is_tensorrrrrr_is_tensorflow_array! s  rcCsxt|tjr|St|dr|St|dr!|j}t|tjr!|St|s-t|s-t|r:t |}t|tjr:|S|S)zDInternal helper to extract data from e.g. pandas and xarray objects.rr6) rJrrhrrr6rrrre)rxtmprrrr0 s      rc Cs.z||fWSttfy||YSw)aA Apply *value* to the format string *fmt*. This works both with unnamed %-style formatting and unnamed {}-style formatting. %-style formatting has priority. If *fmt* is %-style formattable that will be used. Otherwise, {}-formatting is applied. Strings without formatting placeholders are passed through as is. Examples -------- >>> _auto_format_str('%.2f m', 0.2) '0.20 m' >>> _auto_format_str('{} m', 0.2) '0.2 m' >>> _auto_format_str('const', 0.2) 'const' >>> _auto_format_str('%d or {}', 0.2) '0 or {}' )rRrr )rrarrr_auto_format_strK s  rcCr)z#Check if 'x' is a Pandas DataFrame.pandasF)rJr(r) DataFramerrrrr_is_pandas_dataframef rr)rFN)rN)T)F)rNNF)rNr)nrrcollections.abcrrrroroperatorrpathlibrrZr`r(r r@rrPnumpyrnumpy.exceptionsr ImportErrorrrrrr?rBrCrUrWrirkrMatplotlibDeprecationWarningrrrrrrrrrrrrrrcr+r,rNr`rtrzrr ls_mapperrz ls_mapper_rrrrrrrrrrSTEP_LOOKUP_MAPrrrrrrrrr attrgetterrrrrr&r.r7r MutableSetr8rJrRrYr]rirmrtrzrrrrrrrrrrrrrrs  2 7G$  4   7EoMA &K   <b&$&#' 8 (    '21 +! .