h9SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK J r SSK r SSK r SSKrSSKrSSKrSSKrSSKrSSKrSSKJr SSKrSSKJrJr "SS5rSrS r"S S 5rS r"S S5r "SS5r!"SS\"5r#\RHS.Sjr%Sr&Sr'Sr(Sr)S`Sjr*SaSjr+Sr,SbSjr-Sr.\,4Sjr/"S S!5r0ScS"jr1\RdS4S#jr3"S$S%5r4"S&S'5r5S(r6S)r7S*r8SS+.S,jr9SdS-jr:S.S/S0S1S2.r;\;Ry5VVs0sHupX_M snnr=S3r>S4r?S5r@S6rAS7rBSeS8jrCS9rDS:rES;rFS<\D\D\E\FS=.rGS>rHS?rIS@rJSArKSfSBjrL\RSC5rN\R"\P\R"SD5SE94SFjrRSGrSSHrTSIrUSJrVSKrW\RSL5rX"SMSN\RR5r[SOr\SPr]SQr^SRr_SSr`STraSUrbSVrcSWrd\RSfSXj5rfSYrgSZrhS[riS\rjS]rkS^rlS_rmg!\a SSKJr GNf=fs snnf)gz 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_utilsc4\rSrSrSrSr\S5rSrSr g)_ExceptionInfo#a{ 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. cXlX lgN_cls_args)selfclsargss B/var/www/html/env/lib/python3.13/site-packages/matplotlib/cbook.py__init___ExceptionInfo.__init__.s   c:U"[U5/URQ76$r )typer)rexcs rfrom_exception_ExceptionInfo.from_exception2s49(sxx((rc4UR"UR6$r r rs r to_exception_ExceptionInfo.to_exception6syy$**%%r)rr N) __name__ __module__ __qualname____firstlineno____doc__r classmethodrr__static_attributes__rrrr#s%))&rrc[RRS5=(dk [RRS5=(dE [RRS5=(d [RRS5nU(a URR 5(ag[RRS5nU(aRUR S:XaSS KJn UR5(ag UR S :XaUR5(ag [RRS 5nU(aUR5(ag [RRS5nU(aURRURRR1n[R"5R5H3nU(dM UR U;a gUR"nU(aM'M5 A[RRS5nU(aUR%5(ag[&R("5(dgg)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) QtWidgetsGtkr*r.r/codesframer1s r"_get_running_interactive_frameworkrJ:s )* 0 ;;??. / 0 ;;??, - 0 ;;??. /  Y++4466 ++//- .C    ! *      !cnn&6&6  B biikkkkooi(G!!**GLL,A,A,J,JK((*113E%<<5( %4  [[__: ;F &..00  - - / / rcN[5S;aUe[R"5 g)N)r2N)rJ traceback print_exc)rs r_exception_printerrNls)+/AA rc0\rSrSrSrSrSrSrSrSr g) _StrongRefszM Wrapper similar to a weakref, but keeping a strong reference to the object. cXlgr _obj)robjs rr_StrongRef.__init__xs rcUR$r rSrs r__call___StrongRef.__call__{s yyrcb[U[5=(a URUR:H$r ) isinstancerPrT)rothers r__eq___StrongRef.__eq__~s!%,Hejj1HHrc,[UR5$r )hashrTrs r__hash___StrongRef.__hash__sDIIrrSN) rr r!r"r#rrXr]rar%r&rrrPrPssIrrPcf[R"X5$![a [U5s$f=f)zI Return a `WeakMethod` wrapping *func* if possible, else a `_StrongRef`. )weakref WeakMethod TypeErrorrP)funccallbacks r_weak_or_strong_refris2 !!$11  $ s 00c6\rSrSrSrSrSrSrSrSr Sr g ) _UnhashDictz 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. c>0Ul/UlUH up#X0U'M gr _dict_pairs)rpairskvs rr_UnhashDict.__init__s#  DAGrcX RU'g![aX [UR5H unupEXA:XdMX4URU' g URR X45 gf=fr )rorf enumeraterpappend)rkeyvalueirrrss r __setitem___UnhashDict.__setitem__sg 1#JJsO 1&t{{3 6A8&)\DKKN4  ""C<0  1s*A3A3A32A3cURU$![a Of=fURHup#X!:XdM Us $ [U5er )rorfrpKeyError)rrxrrrss r __getitem___UnhashDict.__getitem__sM ::c? "   KKDAx sms  cXR;aURRU5$U(aUS$[ U5e![a< [UR5H unupEXA:XdMURU Us s$ N\f=fNr)ropoprfrvrpr~)rrxrrzrrrss rr_UnhashDict.pops jj zz~~c**! 7Nsm &t{{3 6A8 AH4 s)A*B 2B B  B c#j# URShvN URH upUv M gN7fr rnrrrrss r__iter___UnhashDict.__iter__s,::KKDAG  s 313rnN) rr r!r"r#rr{rrrr%r&rrrkrks  1 rrkc\rSrSrSr\4SS.SjjrSrSrSr S r \ RS .S jr S rS r\R"SS.Sj5rSrg)CallbackRegistryaF 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)signalscUcSO [U5UlXl0Ul[R "5Ul[/5Ul[5Ul gr ) list_signalsexception_handler callbacks itertoolscount_cid_genrk _func_cid_mapset _pickled_cids)rrrs rrCallbackRegistry.__init__sD 'T'] !2!) (_ Urc>0[U5EURR5VVVVs0sH@upXR5VVs0sHup4X0R;dMX4"5_M snn_MB snnnnS[ UR 5S.E$s snnfs snnnnf)N)rrr)varsritemsrnextr)rsdcidproxys r __getstate__CallbackRegistry.__getstate__ s  4j  '+nn&:&:&<>&"T]]+  <>sB B B+B B cURS5n[U5RU5 URR 5VVVVs0sHUup4UUR 5VVs0sH1upVU[ U[ R"URU55_M3 snn_MW snnnnUl[SURR 555Ul [R"U5Ul gs snnfs snnnnf)Nrc3d# UH&upUR5H up4X4U4v M M( g7fr )r).0rrrrs r 0CallbackRegistry.__setstate__.. s5)L.:3Z AJ .s.0)rrupdaterrri functoolspartial _remove_proxyrkrrrr)rstate cid_countrrrrgs r __setstate__CallbackRegistry.__setstate__sIIj)  T % ,,.0/ !",!*IC(y/@/@ASASUV/WXX!*, ,.0))L,,.)LL" 2 ,0s D '8C=D =D czURb[R"URUS9 [U[R "UR U55nURX4$![aG [UR5=o@RX4'X0RRU05U'Us$f=f)z?Register *func* to be called when signal *signal* is generated.signal) rr check_in_listrirrrrr~rrr setdefault)rrrgrrs rconnectCallbackRegistry.connect%s == $   t}}V <#D)*;*;DNN % %fb 1# 6J sA))AB:9B:c^URX5nURRU5 U$)zc Like `.connect`, but the callback is kept when pickling/unpickling. Currently internal-use only. )rradd)rrrgrs r_connect_picklable#CallbackRegistry._connect_picklable1s+ ll6( s# r)_is_finalizingc U"5(agURRX4S5nUb,URUU URR U5 Og[ URU5S:XaURU ggr)rrrrdiscardlen)rrrrrs rrCallbackRegistry._remove_proxy=s|      $$f_d; ?v&s+    & &s +  t~~f% &! +v& ,rcnURRU5 URHup#URX#4U:XdM O gURUUU:XdeURUU URR X#45 [ URU5S:XaURU gg)zs Disconnect the callback registered with callback id *cid*. No error is raised if such a callback does not exist. Nr)rrrrrr)rrrrs r disconnectCallbackRegistry.disconnectJs ""3'!//MF!!&-0C70 ~~f%c*e333 NN6 "3 ' / t~~f% &! +v& ,rchURb[R"URUS9 [URR U05R 55HnU"5nUcMU"U0UD6 M g![a*nURbURU5 SnAMKeSnAff=f)z Process signal *s*. All of the functions registered to receive callbacks on *s* will be called with ``*args`` and ``**kwargs``. Nr) rrrrrr5rA Exceptionr)rrrkwargsrefrgrs rprocessCallbackRegistry.process\s == $   t}}Q 7**1b188:;C5D$)&) <!--9..s33 s0A== B1B,+B,,B1rc## URnUc0UlO"UVs0sHo3U:wdM X2U_M snUlSv X lgs snf!X lf=f7f)a 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. N)r)rrorigrrs rblockedCallbackRegistry.blockedrs[~~ "~!#7;!Jd6k*!!W*d!J !N"K"Ns1 AA A A A AA AA)rrrrrr)rr r!r"r#rNrrrrrr3 is_finalizingrrr contextlibcontextmanagerrr%r&rrrrse6x*<##   3 >A=N=N ''$, $""rrc(\rSrSrSrSSjrSrSrg) silent_listia 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). Nc:XlUbURU5 ggr )rextend)rrseqs rrsilent_list.__init__s ? KK  rcURc[U5S:waCURb URO[US5RnS[U5SUS3$g)Nrz z)rrr)rtps r__repr__silent_list.__repr__sT 99 CIN"ii3d1g9O9OB T 1RD : :$r)rr )rr r!r"r#rrr%r&rrrrs( %rr) warning_clscUnUH<nURUS5nUcMUcUnM![R"SUS3U5 M> U$)N"z"" keyword argument will be ignored)rr warn_external) local_varrrkeysoutrx kwarg_vals r_local_over_kwdictrsW CJJsD)  {""Qse+M#N#.0  Jrc[U5S:a8USUSs=:XaS:Xa%O U$USSnSHupURX5nM U$)z] 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)rtexplains r strip_mathrs\  1v{qtqu++ H aG  JC #%A   Hrc@SnURSU5nURSU5nUS:aUS:aUOUSUnUR5$SUs=::aU:aO OUSUR5$URSUS-5nUS:a[SU<S35eUS-nM)z+Strip everything from the first unquoted #.rr#NrzMissing closing quote in: zM. If you need a double-quote inside a string, use escaping: e.g. "the " char")findstrip ValueError)rpos quote_poshash_poswithout_commentclosing_quote_poss r_strip_commentrs C FF3$ 66#s# q=#+a>% 5'B ^^F # # U)BeH5B    BCCz Irc^[XSU5up4U(aU$[R"U5$)z8Pass through file objects and context-manage path-likes.T)rr nullcontext) path_or_filemoderrrs r open_file_cmr.s*|4BJB27Z33B77rcf[U[5=(d [R"U5(+$)z;Return whether the given object is a scalar or string like.)r[r npiterablevals ris_scalar_or_stringr$4s c3  7r{{3'7#77rc2[SU5nU(azURR5nUS:Xa[R"U5$US;a[ R "U5$US;aUR S5$UR S5$[U5$)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_pathsuffixlowerrrr loadr )r asfileobjpathr*s rget_sample_datar/9s - /D""$ U?99T? " ' '774= / /99S> !99T? "4yrc@[[R"5/UQ76$)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)rs rr)r)Us  ((* 2T 22rc#t# UH,nU"U5(dUcUv M[X!5ShvN M. gN 7f)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)rscalarpitems rr4r4^s6 4==DLJt- - -  .s *86 8cN\rSrSrSrSrSrSrSrSr Sr S r S r S r S rg )_StackitzV Stack of elements with a movable cursor. Mimics home/back/forward in a web browser. c SUl/Ulg)Nr_pos _elementsrs rr_Stack.__init__{s rc SUl/Ulg)zEmpty the stack.rNr:rs rclear _Stack.clears rcZUR(aURUR$S$)z$Return the current element, or None.Nr<r;rs rrX_Stack.__call__s ,0NNt~~dii(DDrc,[UR5$r )rr<rs r__len___Stack.__len__s4>>""rc URU$r )r<)rinds rr_Stack.__getitem__s~~c""rcx[URS-[UR5S- 5UlU"5$)z9Move the position forward and return the current element.r)minr;rr<rs rforward_Stack.forwards- A s4>>':Q'>? v rcL[URS- S5UlU"5$)z6Move the position back and return the current element.rr)maxr;rs rback _Stack.backs A q) v rczU/URURS-S&[UR5S- UlU$)z` Push *o* to the stack after the current position, and return *o*. Discard all later elements. rN)r<r;r)ros rpush _Stack.pushs8 +,tyy1}~&'!+ rcdUR(aURURS5$S$)zS Push the first element onto the top of the stack. The first element is returned. rN)r<rTrs rhome _Stack.homes' 04~~tyy*+G4GrrBN)rr r!r"r#rr?rXrErrLrPrTrWr%r&rrr8r8ts6  E##  Hrr8cd[R"USUS9nURR(d7UR US9R URR S55n[RR[R"U5)USS9nU$![a Us$f=f)NT)subokcopy)inplaceNF)r[) r arraydtypeisnativebyteswapview newbyteorderma masked_whereisfiniterf)rr[xms rsafe_masked_invalidrhs $T*A 77   JJtJ $ ) )!''*>*>s*C D UU  "++a. 115  A I s*4B B/.B/c^^^^^^SSKmU4SjmUUUUUU4SjmTH#nTRSU<S35 T"X30/5 M% g)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. rNc>[U5GH'upXS-[U5-nTRS[U5-5 [ U[ 5(aQUR 5H<upEXSLaTRSU<S35 OXCLdM'TRSU<35 O} Oz[ U[5(a$TRSURU5-5 OA[ U[5(aTRS5 OTR[U55 TRS5 GM* TRS 5 g) Nrz %s -- []z[key] = z[%d]z ( tuple )z ->  ) rvrrrr[dictrrindextuplerepr)r.rzsteprrxr# outstreams r print_path print_cycles..print_paths GAQ#d)+,D OOK$t*4 5$%% $ HC{!!C7! 5{!(3'(:; !-D$''D)9 9:D%(( ,T + OOG $''( rcB>T (aTRS[U5-5 SU[U5'TRU5nUHUnXQLa T "U5 MUTLd[ U[ R 5(aM7[U5U;dMHT "XQX#U/-5 MW g)Nz%d )rrid get_referentsr[types FrameType) rUstartall current_path referentsreferentgcobjectsrsrtrecurse show_progresss rrprint_cycles..recurses  OOFSX- .BsG $$S) !H <( W$ 8U__(M(MHS(cU.BC"rz Examining: rm)rr)rrsrrUrrtrs``` @@@r print_cyclesrsF .DD.+cWB/0"b!rcR\rSrSrSrSSjrSrSrSrSr Sr S r S r S r S rg )Grouperia 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 c p[R"UVs0sHo"[R"U/5_M sn5Ul[R"5UlUH6nX R;dM[ UR5URU'M8 [ UR5Ulgs snfr )rdWeakKeyDictionaryWeakSet_mapping _orderingr _next_order)rinitrs rrGrouper.__init__ s11.2 3d$ $d 35  224A&$'$7q!t~~. 4s!B3c 0[U5EURR5VVs0sHupU[U5_M snn0URES.E$s snnf)N)rr)rrrrrrs rrGrouper.__getstate__)s\ 4j 04}}/B/B/DE/DtqCF/DE+DNN+   FsAc H[U5RU5 [R"URR 5VVs0sHup#U[R "U5_M snn5Ul[R"UR5Ulgs snnfr )rrrdrrrrr)rrrrrss rrGrouper.__setstate__1st T % 11/3}}/B/B/D E/DtqQ" "/D EG  224>>B Fs#B cXR;$r )rrr6s r __contains__Grouper.__contains__8s}}$$rc"URnX1nUHFnX5nXdLdM[ U5[ U5:aXdpdURU5 UHnXCU'M MH g![aL [R"U/5=oCU'URUR U'U=RS- slNf=f![aL [R"U/5=ocU'URUR U'U=RS- slNf=f)zI Join given arguments into the same set. Accepts one or more arguments. rN)rr~rdrrrrr)rarmappingset_aargset_belems rjoin Grouper.join;s-- "JE C &  !u:E *#(5 U#!D$)DM"  "!(!!5 5EAJ $ 0 0DNN1     !  " &'.u'== &*&6&6s#  A%  &s$AB8AB54B58AD DcURRU[55URRU5L$)z7Return whether *a* and *b* are members of the same set.)rr5objectrrbs rjoinedGrouper.joinedTs/ !!!VX.$--2C2CA2FFGrcURRX15RU5 URRUS5 g)z>Remove *a* from the grouper, doing nothing if it is not there.N)rrremoverrrs rrGrouper.removeXs5 !S!((+ 1d#rc## URR5Vs0sHn[U5U_M nnUR5H"n[XRR S9v M$ gs snf7f)zq Iterate over each of the disjoint sets as a list. The iterator is invalid if interleaved with calls to join(). rxN)rrArwsortedrr)rgroup unique_groupss rrGrouper.__iter__]sa 8<}}7K7K7MN7MeEE)7M N"))+ENN$>$>? ?,OsA3A.>A3ctURRX/5n[X RRS9$)z:Return all of the items joined with *a*, including itself.r)rr5rr)rrsiblingss r get_siblingsGrouper.get_siblingsgs-==$$Q,hNN$6$677r)rrrN)r&)rr r!r"r#rrrrrrrrrr%r&rrrrs8B/ C%*2H$ @8rrc6\rSrSrSrSrSrSrSrSr Sr g ) GrouperViewimz!Immutable view over a `.Grouper`.cXlgr _grouper)rgroupers rrGrouperView.__init__psrcXR;$r rrs rrGrouperView.__contains__qs)>">rc,[UR5$r )iterrrs rrGrouperView.__iter__rstDMM22rc8URRX5$)z9 Return whether *a* and *b* are members of the same set. )rrrs rrGrouperView.joinedts}}##A))rc8URRU5$)z< Return all of the items joined with *a*, including itself. )rrrs rrGrouperView.get_siblingszs}}))!,,rrN) rr r!r"r#rrrrrr%r&rrrrms+8>2* -rrc UR[U5S45n[R"[U55U-n[R"[U5S- U-S-5n[R"UR Vs/sHn[R "XCU5PM sn5R[U54URSS-5$s snf)aM 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, ...)`` rrN)reshaperr arange column_stackTinterpshape)rstepsfpsxprfps rsimple_linear_interpolationrs" ))SVRL !C 3q6 U "B 3q6A:&*+A OOCEEBEbRYYqb1EB C Wc!fY, -/Bs!Cc[U5(dg[US5(a [S5e[US5n/nS/[U5-n[U5HupE[ U[ 5(d[ R"U5(an[U5U:Xa_SX4'[ U[ RR5(aURS:a [S5eO[ R"U5nURU5 M /n[U5HupEX4(dMURS:aM"[ U[ RR5(a<UR[ RRU5)5 URnOUn[ R"U5n[ U[ R 5(aURU5 MM [U5(af[ R$R'U5nUR)5Sn [U 5U:a%[U5HupEX4(dMXYX$'M [U5HMupEX4(dM[ U[ RR5(dM;UR+5X$'MO U$!["a GMf=f)a 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(). r&r!First argument must be a sequenceFTrMasked arrays must be 1-D)rr$rrvr[r r r!rd MaskedArrayndimasarrayrw getmaskarraydatarfndarrayr logical_andreducenonzerofilled) rnrecsmargsseqlistrzrmasksxdmaskigoods rdelete_masked_pointsrs-@ t9947##<== QLE EgD !G$!S!!bkk!nnQ5GJ!RUU..//66A:$%@AAJJqM Q  E%  ::vvz!RUU..// bee00334VV {{2dBJJ//LL&0! 5zz~~$$U+ q! u: !%(:: xEH)%  ::*Q(9(9::xxzEH! L  s)AK  KKc*[U5(dg[US5(a [S5e[US5n/nS/[U5-n/n[U5GHupV[U5(d[U5U:waUR U5 M8[ U[ RR5(aURS:a [S5e[ R"U5nURS:Xaa[U5nSX5'[ RRU5(a.UR [ RRU55 UR U5 GM [U5(a][ R R#U5n[U5H/upVX5(dM[ RR%XgS 9X%'M1 U$![[4a [ R"U[S9nGN"f=f) a 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. r&rrFrrr_Tr)rr$rrvrwr[r rdrr asanyarrayrrrh is_maskedr logical_orrr^)rrrrrrzrrs r_combine_masksrs> t9947##<== QLE EgD !G E$ q ! !SVu_ LLO!RUU..//AFFQJ !<== 3MM!$ vv{'*! 55??1%%LL!3!3A!67 LLO# $ 5zz}}##E*e$DAzz55;;q;4% L.z: 3MM!62 3sG%%)HH)compressc UVs/sH:n[U[RR5(dM.URPM< nn[R "/UQUQ76nUS[ U5nU[ U5SnU(a[RRU5nU(a=UVs/sH.n[RRX&S9R5PM0 nnU$UVs/sHPn[RRX&[S9R[R5R5PMR nnU$UVs/sHn[R"U5PM nnU$s snfs snfs snfs snf)aC 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. Nr)rr_)r[r rdrrbroadcast_arraysrrrr^ compressedfloatrnanravel)rrrrrbcastinputsrs r_broadcast_with_masksr'sN$" FTZ2553D3D%EVQVVTE F    . . .E :CI F #d)* E }}##E* %'%!eekk!k/::<% ' M &'%!eekk!ek<CCBFFKQQS% 'F M(..v!"((1+v. M# G''/s-E.E.-5E3*AE8 E=c^SSjmU4Sjn/n[US5n[U5nUc[R"S5nO[U5U:wa [ S5eUn[ [ X55GHun up0n U bXS'UnURU 5 [U 5S:Xa[R"/5U S'[RU S '[RU S '[RU S '[RU S '[RU S '[RU S'[RU S'[RU S'[RU S'M[RRU 5n U RU R)R5n [R "U 5U S '[R""U /SQ5upnX- U S 'U S S:Xa U(aSnU"XU S U5uU S'U S'[R$"U5(a/['U[(5(d[R""X5unnO;[R*"U5(aXU S -- nXU S --nO [ S5eXU:*n[U5S:Xd[R,"U5U:aXS'O[R,"U5U S'XU:n[U5S:Xd[R."U5U :aXS'O[R."U5U S'[R0"XU S:XU S:/5U S'XUsU S 'U S 'U S 'GM U$)av 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. c[U5nSS/n[RRX!U4S9nXn[R"USSS9n[R "Xc5nU$)Ng@g`X@)sizerT)axisoverwrite_input)rr randomrandintmedian percentile)rr]M percentilesbs_indexbsDataestimateCIs r_bootstrap_median(boxplot_stats.._bootstrap_medians[ IDk 99$$QV$499V!TB ]]8 1 rc>UbT"XS9nUSnUSnXV4$[U5nUSU-[R"U5- - nUSU-[R"U5- -nXV4$)N)r]rrgQ?)rr sqrt) rmediqr bootstrapr notch_min notch_maxr]rs r_compute_conf_interval-boxplot_stats.._compute_conf_intervals|  #45B1I1I## D AdSj2771:55IdSj2771:55I##rXNz-Dimensions of labels and X must be compatiblelabelrfliersmeanr q1q3r cilocihiwhislowhishi)2K)rdz+whis must be a float or list of percentiles)i) _reshape_2Drrrepeatrrvziprwr r^rrdrrrrrrr!r[r isrealrOrK concatenate)rwhisr labels autorangerbxpstatsncols input_whisiirrstatsrr rlovalhivalwiskhiwisklors @r boxplot_statsr0Ms^  $ H AsA FE ~!!$' V HIIJ#CN3JQ  "'N  q6Q; hhrlE(OFFE&M66E%L&&E$K&&E$K66E%LFFE&MFFE&M ffE(O ffE(O  EEMM!  FFAFF7O ! ! # f mmA|4 we <1 D(> E%L)( $f uV} ;;t  Zc%:%:==1LE5 YYt__e ,,Ee ,,EJK K: v;! rvvf~2 (O ffVnE(O: v;! rvvf~2 (O ffVnE(O.. %/! " %/! "*  h 24".d U5\5;[4^ Orsoliddasheddashdotdotted)-z--z-.:c p[R"U[S9nUR(d/$[R"USSUSS:g5unUS- nUR 5nUS(aS/U-nUS(aUR [U55 [[USSS2USSS255$)zj Return a list of (ind0, ind1) such that ``mask[ind0:ind1].all()`` is True and we cover all such regions. rNrrrr) r rboolrrtolistrwrrr!)ridxs rcontiguous_regionsr;s ::d$ 'D 99  ::d3Bi48+ ,DC1HC **,C AwcCi Bx 3t9 C!Hc!$Q$i( ))rc[U5nURS5URS5- nUS:=(a US-S:HnU$)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)r r)r dollar_count even_dollarss r is_math_textr?6sF AA774=1775>1L 1$>)9Q)>L rc[US5(aA[RRU[5R [R 5$[R"U[5$)zh Convert a sequence to a float array; if input was a masked array, masked values are converted to nans. r)rr rdrrrrrs r_to_unmasked_float_arrayrACsF q&uu}}Q&--bff55zz!U##rc[U5n[US5(a*[US5(a[UR5S:a[R "U5$U$)z8Convert scalars to 1D arrays; pass-through arrays as is.rrr)_unpack_to_numpyrrrr  atleast_1drs r _check_1drENsN A Aw  6"" L1 }}Qrc.[U5n[U[R5(aURn[ U5S:Xa//$UR S:Xa [R "US5S:XaU/$UR S;a(UVs/sHn[R"US5PM sn$[US35e[ U5S:Xa//$/nSnUHn[U[5(d[U5 Sn[R"U5n[R "U5nUS:a[US35eURURS55 M U(a[R"US5/$U$s snf![a Nf=f)ap 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)rrrz must have 2 or fewer dimensionsTF)rCr[r rrrrrrr rrfrrw)rnamerresultis_1dxinds rrr]sl A!RZZ  CC q6Q;4K VVq[RWWQqT]a/3J VVv /01q!BJJq"%q1 1v%EFG G 1v{t F E"c"" R ]]2  WWR[ 6v%EFG G bjjn%   62&'' ?2   s !F0 F FFc/n[US5nUb[U5S:wa [US5nO//[U5-n[U5[U5:wa [S5e[X5HupV0n[R "U5n[R "U5n [R"USU-5n [R"XU5n U"X[5US'XS'[R"U5US'[R"U5US 'XS 'XS '[R"U 5US'URU5 M U$) 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. rr quantileszLList of violinplot statistics and quantiles values must have the same lengthrvalscoordsrrrKrO) rrrr!r rKrOrlinspacerrrDrw) rmethodpointsrMvpstatsrqr+min_valmax_val quantile_valrOs r violin_statsrXs5jG AsAY1!4 ;7 D3q6M  1vY67 7a#&&)&&)}}Qa0 Wv6q)f  h f ))A,he e ]]<8k u-$0 Nrc [R"S[U5-[S[U5-S- S545nXSSSS24'USSSS24USSSS24'XSS2SSS24'USS2SSS24USS2SSS24'U$)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) rrrNr zerosrrOrrrs rpts_to_prestepr^s8 HHa#d)mSSVa%;< =E!QTT'N1a1f9%E!QTT'N!"add(OAB1HoE!"add(O Lrc [R"S[U5-[S[U5-S- S545nXSSSS24'USSSS24USSSS24'XSS2SSS24'USS2SSS24USS2SSS24'U$)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) rrrNrZr[r]s rpts_to_poststepr`!s8 HHa#d)mSSVa%;< =E!QTT'N1add7^E!QTT'N!"add(OAB"QJ'E!"add(O LrcD[R"S[U5-S[U5-45n[R"U5nUSSUSS-S- =USSSS24'USSSS24'USSUSSS24'USSUSSS24'XSS2SSS24'USS2SSS24USS2SSS24'U$)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)r r\rrr]s rpts_to_midsteprbEs8 HHa#d)mQQZ0 1E aA)*3B!AB%1(<reksA6r)defaultrz steps-prez steps-postz steps-midc"URR5UR54$![a Of=f[U5n[R "UR S[S9U4$![[4a Of=f[S5e)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. rrz5Input could not be cast to an at-least-1D NumPy array) roto_numpyAttributeErrorrEr rrrrr)rds rindex_ofrjrs* ww!1::<//    5 aL yy51144 &z 2   L MMs), 99 A00BBc[U[RR5(aUS$[ [U55$![a Of=f[ S5e)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)r[ collectionsabcIteratorrf RuntimeErrorrrrs rsafe_first_elementrqsY#{//00  q6M S ?   LMMsA AAcSn[U[R5(aUS$[U[RR 5(a [ S5eUHnU"U5(dMUs $ [U5$)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. cUcg[R"U5$![[4a Of=f[R "U5(a[R"U5$S$![a gf=f)NFT)mathrfrfrr isscalarr"s r safe_isfinite)_safe_first_finite..safe_isfinitesr ; ==% %:&      '){{3'7'72;;s# AT A  s#//0A&$A&& A32A3rrl)r[r flatiterrmrnrorprq)rUrvr#s r_safe_first_finiterysm"#r{{##1v C11 2 2LMMCS!! "#&&rcn[U[RR5(a [ U5$U$)zH Convert dictview objects to list. Other inputs are returned unchanged. )r[rmrn MappingViewr)rs rsanitize_sequencer|s.%T;??+F+FGGDJrcSSKJn Uc0$Uc0nOB[U[5(a[ X5(d[X5(a [ US05nUR 5VVVs0sHup4UHnXS_M M nnnn0n0nUR 5H9upURX5nX7;a[SXs<SU <S35eXU'XU'M; U$s snnnf)a 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)Artist _alias_mapz Got both z and z", which are aliases of one another) matplotlib.artistr~r[r issubclassrrr5rf) kw alias_mappingr~ canonical alias_listalias to_canonicalcanonical_to_seenretrrrss rnormalize_kwargsrs6) z  ]D ) )j.O.O  . . |R@ 2?1D1D1F-1F- !+$!+1F- C  $$Q*  )i(9(D'Gu e#EGH H'()$I  J-s(Cc## [U5nURURS-5nSnSn[U5HnUR S5 SSS5 O [SRU55eSv UR5 g!,(df  Mb=f![ a [ R"U5 Mf=f!UR5 f=f7f)aB 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_namerGrangerFileExistsErrortimesleep TimeoutErrorformatunlink)r. lock_pathretries sleeptime_s r _lock_pathrs :Dtyy+==>IGI 7^ "%&%HIO I    &% " JJy ! " sd>> 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)r s_r#)arrrLbackwards r_array_perimeterrZsg:eeAbkGuuR"W~H >> AwJ RK BL aK  rc/URQUPn/URQURUPnXAU- U-S-XA'XQU-XQ'[RRR UUUSS9$)au 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)rstrides writeable)rrr lib stride_tricks as_strided)rrrrr new_shape new_stridess r_unfoldrsP##))"T"I3CKK3T!23K -$6:IO#)D0K 66   * *31:3>5: + <wr1 1235rc+# [5n0nUH\n[XU5nX@R;dXRLaXSU'M([[U5U5n[ U[ 5(aXSU'MXX#U'M^ UR 5HupG[XU5 M Sv UR 5H"upEXRLa [X5 M[XU5 M$ g!UR 5H"upEXRLa [X5 M[XU5 M$ f=f7f)zJ Temporarily set some attributes; restore original state at context exit. N) rr__dict__rr[propertyrsetattrdelattr)rUrsentinelorigsattrrcls_origr#s r _setattr_cmrs xH Es(+ << 4#3$KtCy$/H(H--"d 'd /2 )ID Cs #( ++-JD"4( (%++-JD"4( (sA/D 2)C7D 8D  D c8\rSrSrSrSrSrSrSrSr Sr g ) _OrderedSetic8[R"5Ulgr )rm OrderedDict_odrs rr_OrderedSet.__init__s**,rcXR;$r rrrxs rr_OrderedSet.__contains__shhrc,[UR5$r )rrrs rr_OrderedSet.__iter__sDHH~rc,[UR5$r )rrrs rrE_OrderedSet.__len__s488}rcZURRUS5 SURU'gr rrrs rr_OrderedSet.adds!  S$ rc<URRUS5 gr rrs rr_OrderedSet.discard!s  S$rrN) rr r!r"rrrrErrr%r&rrrrs - rrc[R"U[RS:Xa/SQO/SQSS9nUSSS24nUS nUS :gn[R"US5H,nXTR [ 5S -X4S--X4-XT'M. U$) zK Convert a premultiplied ARGB32 buffer to an unmultiplied RGBA8888 buffer. littlerrrr,)rrr,rrr.Nr).rr)r taker3 byteorderrollaxisastypeint)bufrgbargbalpharchannels r._premultiplied_argb32_to_unmultiplied_rgba8888r)s 77  1 |! MD sCRCx.C ME A:D;;sB' ] ! !# & ,u{a/? ?{   ( Krc2[RS:Xa+[R"U/SQSS9nUSSS24nUSSS24nO*[R"U/SQSS9nUSSS 24nUSS S24nUR 5S :wa[R "X#S - US S 9 U$) zK Convert an unmultiplied RGBA8888 buffer to a premultiplied ARGB32 buffer. rrrr.Nr)r,rrrrrunsafe)rcasting)r3rr rrKmultiply)rgba8888argb32rgb24alpha8s r._unmultiplied_rgba8888_to_premultiplied_argb32r;s }} [U5(a.USS/up4USS/upV[XVS-5[X4S-54$[SS5[SS54$)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. rrrr)anyrrslice)rx_nzy_nzlr'rts r_get_nonzero_slicesrOs GGGO # # %ED GGGO # # %ED 4yySYYQG}QG}QAaQ//Q{E!QK''rc`[U[5(aU$SRSU55$)zAPretty-format a subprocess command for printing/logging purposes.rc3v# UH/n[R"[R"U55v M1 g7fr )shlexquoter r )rrs rr&_pformat_subprocess..ds$I#%++biin55s79)r[r r)commands r_pformat_subprocessras/!'3//GKIIIKrc VURS[U55 [R"U4SS0UD6nUR(aUR n[ U[5(aUR5nURn[ U[5(aUR5n[S[U5SUSU35eUR (aURSUR 5 UR(aURSUR5 UR $) aR 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 returncodestdoutr[bytesdecodestderrrp)rloggerrprocrr s r_check_and_log_subprocessr gs LL*734 >>' A$ A& AD  fe $ $]]_F fe $ $]]_F&w/01;h)h    {{ ]DKK0 {{ ]DKK0 ;;rc|[R"5 g![a [R"S5 gf=f)zK Perform OS-dependent setup when Matplotlib creates a new GUI application. r1N)r-Win32_GetCurrentProcessExplicitAppUserModelIDOSError-Win32_SetCurrentProcessExplicitAppUserModelIDr&rr_setup_new_guiapprs3GGI GG  s  ;;c`USUS3RS5RS5=(d S$)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 precisions r_format_approxrs2 QykN # + +C 0 7 7 < CCrc |US:Xa&US:Xag[[R"U55n[R"U5(at[ SU(a6[R "[R"[U555S-OS[R "[R"U55- 5$S$)zs Return the number of significant digits to %g-format *value*, assuming that it is known with an error of *delta*. rr,r)absr spacingrtrfrOfloorlog10)rydeltas r _g_sig_digitsr s  z A:BJJu%&-1MM%,@,@  38DJJs5z* +a /a **TZZ& ' ( )HGHHrcU(aUR5(aU$UR5nURS5(aUSSnURS5(aURSS5nUR S5(aUSSn[ R S:XaUS :XaS nS S S S.RX"5nU$)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_rrZdarwinmetacmdenterpageuppagedown)returnpriorr) isprintabler+ startswithrrr3platformr5)unikeykeysymrxs r_unikey_or_keysym_to_mplkeyr4s&$$&& ,,.C ~~e!"g ~~gkk'6* ||L!!#2h ||xC6M  c#m  Jrcd^^^[RUUU4Sj5nTRUlU$)aL 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. c>^[UT5(aU$Um"UUUU4SjSTT5nTRTR5=UlUlTb [ UTT5 U$)NcB>\rSrSrYRrUUUU4SjrSrg):_make_class_factory..class_factory..subclsic:>[TTTT4UR54$r )_picklable_class_constructorr)r attr_name base_classfmt mixin_classs r __reduce__E_make_class_factory..class_factory..subcls.__reduce__s(4$c9jA))+--rr&N)rr r!r"r?r%)r;r<r=r>srsubclsr8s$//J - -rrA)rrrr!r) axes_classrAr<r;r=r>s @r class_factory*_make_class_factory..class_factorysi j+ . .   - -[* -14 :;N;N0OO&-  FIz 2 r)rcacher )r>r=r;rCs``` r_make_class_factoryrFs1&__. +55M rcL[XU5nU"U5nURU5$)z(Internal helper for _make_class_factory.)rF__new__)r>r=r;r<factoryrs rr:r: s'!+I>G * C ;;s rcr[U[RSR5$![a gf=f)z!Check if 'x' is a PyTorch Tensor.torchF)r[r3r4Tensorrrs r_is_torch_arrayrM s9!S[[18899  &) 66cr[U[RSR5$![a gf=f)zCheck if 'x' is a JAX Array.jaxF)r[r3r4Arrayrrs r _is_jax_arrayrR s9!S[[/5566 rNc|[U[RSRU55$![a gf=f)z0Check if 'x' is a TensorFlow Tensor or Variable. tensorflowF)r[r3r4 is_tensorrrs r_is_tensorflow_arrayrV! s>  !S[[6@@CDD s +. ;;c[U[R5(aU$[US5(aUR 5$[US5(a-UR n[U[R5(aU$[ U5(d [U5(d[U5(a7[R"U5n[U[R5(aU$U$)zDInternal helper to extract data from e.g. pandas and xarray objects.rhrA) r[r rrrhrArMrRrVr)rxtmps rrCrC0 s!RZZ  q*zz|q(xx dBJJ ' 'Kq]1--1Ea1H1H zz!} dBJJ ' 'K Hrc\X4-$![[4a URU5s$f=f)a 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 {}' )rfrr)r=rys r_auto_format_strrZK s4*!X~ z "!zz%  !s !++cr[U[RSR5$![a gf=f)z#Check if 'x' is a Pandas DataFrame.pandasF)r[r3r4 DataFramerrs r_is_pandas_dataframer^f s9!S[[2<<== rN)r'FN)r'N)T)F)g?NNF)rNr )nr#rmcollections.abcrrrrrtoperatorr pathlibrrrr3rrLryrdnumpyr numpy.exceptionsr ImportErrorr1rrrrJrNrPrirkrrrMatplotlibDeprecationWarningrrrrrrrr$r/r)r4r8rhrrrrrrrrr0 ls_mapperr ls_mapper_rr;r?rArErrXr^r`rbSTEP_LOOKUP_MAPrjrqryr|rrrrrO attrgetterrrrrrrrrn MutableSetrrrrrr rrr r4rErFr:rMrRrVrCrZr^)rrrss00rrks       0:.&&./d$ 44nC"C"L%$%H55  .((1 1h8 8 83-.,4H4Hn %(JJeB"Jl8l8^--(/0JZ>B+0#LFT J ) 12 1qt 12 *4 $ 9x_D#L!H#L2* .!0 . 0 NF($'N5p ##P%%cx/B/B8/LM *-5$N/