mrhavens/intellecton
1
0
Fork 0
mirror of http://forgejo.openclaw.svc.cluster.local:3000/mrhavens/intellecton.git synced 2026-06-18 01:22:57 +00:00
Code Issues Projects Packages Wiki Activity
intellecton/venv/lib/python3.12/site-packages/matplotlib/__pycache__/cbook.cpython-312.pyc

1105 lines
96 KiB
Text
Raw Normal View History

feat: rigorous physics revision for Paper 1 based on adversarial review
2026-06-01 22:22:35 +00:00
<EFBFBD>
<00>Rj<>8<00><00><><00>dZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZ ddlmZddlZddlmZmZGd<06>d<07>Zd<08>Zd <09>ZGd
<EFBFBD>d <0B>Zd <0C>ZGd <0A>d<0E>Z Gd<0F>d<10>Z!Gd<11>de"<22>Z#ejHd<13>d<14>Z%d<15>Z&d<16>Z'd<17>Z(d<18>Z)d`d<1A>Z*dad<1B>Z+d<1C>Z,dbd<1D>Z-d<1E>Z.e,fd<1F>Z/Gd <20>d!<21>Z0dcd"<22>Z1ejddfd#<23>Z3Gd$<24>d%<25>Z4Gd&<26>d'<27>Z5d(<28>Z6d)<29>Z7d*<2A>Z8dd+<2B>d,<2C>Z9ddd-<2D>Z:d.d/d0d1d2<64>Z;e;jy<00>D<00><00>cic]\}}||<00><02>
c}}Z=d3<64>Z>d4<64>Z?d5<64>Z@d6<64>ZAd7<64>ZBded8<64>ZCd9<64>ZDd:<3A>ZEd;<3B>ZFd<<3C>eDeDeEeFd=<3D>ZGd><3E>ZHd?<3F>ZId@<40>ZJdA<64>ZKdfdB<64>ZLej<>dC<64><00>ZNej<>ePej<>dD<64><00>E<EFBFBD>fdF<64>ZRdG<64>ZSdH<64>ZTdI<64>ZUdJ<64>ZVdK<64>ZWej<>dL<64><00>ZXGdM<64>dNej<>j<><00>Z[dO<64>Z\dP<64>Z]dQ<64>Z^dR<64>Z_dS<64>Z`dT<64>ZadU<64>ZbdV<64>ZcdW<64>Zdej<>dfdX<64><01>ZfdY<64>ZgdZ<64>Zhd[<5B>Zid\<5C>Zjd]<5D>Zkd^<5E>Zld_<64>Zmy#e$r
ddlmZY<00><01><>wxYwcc}}w)gz<67>
A collection of utility functions and classes. Originally, many
(but not all) were from the Python Cookbook -- hence the name cbook.
<EFBFBD>N)<01>Path)<01>VisibleDeprecationWarning)<02>_api<70>_c_internal_utilsc<00>,<00>eZdZdZd<02>Zed<03><00>Zd<04>Zy)<06>_ExceptionInfoa<6F>
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.
c<00> <00>||_||_y<00>N<><02>_cls<6C>_args)<03>self<6C>cls<6C>argss <20>S/home/antigravity/intellecton/venv/lib/python3.12/site-packages/matplotlib/cbook.py<70>__init__z_ExceptionInfo.__init__.s<00><00><17><04> <09><19><04>
<EFBFBD>c<00>:<00>|t|<01>g|j<00><01><06>Sr
)<02>typer)r<00>excs r<00>from_exceptionz_ExceptionInfo.from_exception2s<00><00><12>4<EFBFBD><03>9<EFBFBD>(<28>s<EFBFBD>x<EFBFBD>x<EFBFBD>(<28>(rc<00>4<00>|j|j<00>Sr
r <00>rs r<00> to_exceptionz_ExceptionInfo.to_exception6s<00><00><18>t<EFBFBD>y<EFBFBD>y<EFBFBD>$<24>*<2A>*<2A>%<25>%rN)<08>__name__<5F>
__module__<EFBFBD> __qualname__<5F>__doc__r<00> classmethodrr<00>rrrr#s%<00><00><08><1A><11>)<29><11>)<29>&rrc<00>D<00>tjjd<01>xsatjjd<02>xs@tjjd<03>xstjjd<04>}|r|jj <00>rytjjd<06>}|rF|j
dk(rdd lm}|j<00>ry
|j
d k(r|j<00>ry tjjd <0A>}|r|j<00>ry tjjd<0E>}|r<>|jj|jjjh}tj<00>j<00>D]$}|s<01>|j |vry|j"}|r<01><1F>&~tjjd<10>}|r|j%<00>ryt'j(<00>syy)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.QtWidgets<74>qtzgi.repository.Gtk<74>r)<01>GLib<69>gtk4<6B><00>gtk3<6B>wx<77>tkinter<65>tkzmatplotlib.backends._macosx<73>macosx<73>headlessN)<15>sys<79>modules<65>get<65> QApplication<6F>instance<63> MAJOR_VERSION<4F> gi.repositoryr$<00>
main_depth<EFBFBD>
main_level<EFBFBD>GetApp<70>mainloop<6F>__code__<5F>Misc<73>_current_frames<65>values<65>f_code<64>f_back<63>event_loop_is_runningr<00>display_is_valid)<08> QtWidgets<74>Gtkr$r(r)<00>codes<65>framer+s r<00>"_get_running_interactive_frameworkrD:s<><00><00> <0C> <0B> <0B><0F><0F>)<29>*<2A> 0<> <0E>;<3B>;<3B>?<3F>?<3F>.<2E> /<2F> 0<> <0E>;<3B>;<3B>?<3F>?<3F>,<2C> -<2D> 0<> <0F>;<3B>;<3B>?<3F>?<3F>.<2E> /<2F> <0E> <11>Y<EFBFBD>+<2B>+<2B>4<>4<>6<><13>
<0A>+<2B>+<2B>/<2F>/<2F>-<2D>
.<2E>C<EFBFBD>
<EFBFBD> <0E> <1C> <1C><01> !<21> *<2A><13><EFBFBD><EFBFBD> <20><1D> <0E> <1C> <1C><01> !<21>c<EFBFBD>n<EFBFBD>n<EFBFBD>&6<><19> <0C><1B><1B><1F><1F><14> <1E>B<EFBFBD> <09>b<EFBFBD>i<EFBFBD>i<EFBFBD>k<EFBFBD><13><11>k<EFBFBD>k<EFBFBD>o<EFBFBD>o<EFBFBD>i<EFBFBD>(<28>G<EFBFBD><0E><18>!<21>!<21>*<2A>*<2A>G<EFBFBD>L<EFBFBD>L<EFBFBD>,A<>,A<>,J<>,J<>K<><05><18>(<28>(<28>*<2A>1<>1<>3<> %<25>E<EFBFBD><17><18><<3C><<3C>5<EFBFBD>(<28><1F><1D> <0C> <0C><05><18> %<25> <12> <10>[<5B>[<5B>_<EFBFBD>_<EFBFBD>:<3A> ;<3B>F<EFBFBD> <0A>&<26>.<2E>.<2E>0<><17> <1C> -<2D> -<2D> /<2F><19> rc<00>H<00>t<00>dvr|<00>tj<00>y)N)r,N)rD<00> traceback<63> print_exc)rs r<00>_exception_printerrHls<00><00>)<29>+<2B>/A<>A<><11> <09><11><1B><1B>rc<00>(<00>eZdZdZd<02>Zd<03>Zd<04>Zd<05>Zy)<07>
_StrongRefzU
Wrapper similar to a weakref, but keeping a strong reference to the object.
c<00><00>||_yr
<00><01>_obj)r<00>objs rrz_StrongRef.__init__xs <00><00><17><04> rc<00><00>|jSr
rLrs r<00>__call__z_StrongRef.__call__{s <00><00><13>y<EFBFBD>y<EFBFBD>rc<00>X<00>t|t<00>xr|j|jk(Sr
)<03>
isinstancerJrM)r<00>others r<00>__eq__z_StrongRef.__eq__~s!<00><00><19>%<25><1A>,<2C>H<><14><19><19>e<EFBFBD>j<EFBFBD>j<EFBFBD>1H<31>Hrc<00>,<00>t|j<00>Sr
)<02>hashrMrs r<00>__hash__z_StrongRef.__hash__<5F>s<00><00><13>D<EFBFBD>I<EFBFBD>I<EFBFBD><EFBFBD>rN)rrrrrrPrTrWr rrrJrJss<00><00><08><18><19>I<01>rrJc<00>d<00> tj||<01>S#t$rt|<00>cYSwxYw)zQ
Return a `WeakMethod` wrapping *func* if possible, else a `_StrongRef`.
)<04>weakref<65>
WeakMethod<EFBFBD> TypeErrorrJ)<02>func<6E>callbacks r<00>_weak_or_strong_refr^<00>s4<00><00> <20><16>!<21>!<21>$<24><08>1<>1<><31> <14> <20><19>$<24><1F><1F> <20>s <00><00>/<03>/c<00>.<00>eZdZdZd<02>Zd<03>Zd<04>Zd<05>Zd<06>Zy)<08> _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.
c<00>><00>i|_g|_|D]
\}}|||<<00> yr
<00><02>_dict<63>_pairs)r<00>pairs<72>k<>vs rrz_UnhashDict.__init__<5F>s,<00><00><17><04>
<EFBFBD><18><04> <0B><19> <18>D<EFBFBD>A<EFBFBD>q<EFBFBD><17>D<EFBFBD><11>G<EFBFBD> rc<00><><00> ||j|<y#t$rYt|j<00>D]!\}\}}||k(s<01>||f|j|<Yy|jj ||f<02>YywxYwr
)rcr[<00> enumeraterd<00>append)r<00>key<65>value<75>irfrgs r<00> __setitem__z_UnhashDict.__setitem__<5F>sv<00><00> 1<>#<23>D<EFBFBD>J<EFBFBD>J<EFBFBD>s<EFBFBD>O<EFBFBD><4F><18> 1<>&<26>t<EFBFBD>{<7B>{<7B>3<> 1<> <09><01>6<EFBFBD>A<EFBFBD>q<EFBFBD><14><03>8<EFBFBD>&)<29>5<EFBFBD>\<5C>D<EFBFBD>K<EFBFBD>K<EFBFBD><01>N<EFBFBD><19> 1<>
<15> <0B> <0B>"<22>"<22>C<EFBFBD><15><<3C>0<>  1<>s<00><00>,A4<03>A4<03>A4<03>3A4c<00><><00> |j|S#t$rYnwxYw|jD]\}}||k(s<01> |cSt|<01><00>r
)rcr[rd<00>KeyError)rrkrfrgs r<00> __getitem__z_UnhashDict.__getitem__<5F>sV<00><00> <11><17>:<3A>:<3A>c<EFBFBD>?<3F> "<22><><18> <11> <10> <11><><18>K<EFBFBD>K<EFBFBD> <19>D<EFBFBD>A<EFBFBD>q<EFBFBD><10>C<EFBFBD>x<EFBFBD><18><08> <19><17>s<EFBFBD>m<EFBFBD>s <00><00> <03>c<00>
<00> ||jvr|jj|<01>S |r|dSt |<01><00>#t$r;t|j<00>D] \}\}}||k(s<01>|j|=|ccYSY<00>UwxYw<01>Nr)rc<00>popr[rirdrp)rrkrrmrfrgs rrtz_UnhashDict.pop<6F>s<><00><00> <1D><12>d<EFBFBD>j<EFBFBD>j<EFBFBD> <20><1B>z<EFBFBD>z<EFBFBD>~<7E>~<7E>c<EFBFBD>*<2A>*<2A>!<21> <10><17><01>7<EFBFBD>N<EFBFBD><16>s<EFBFBD>m<EFBFBD><1B><><19> <1D>&<26>t<EFBFBD>{<7B>{<7B>3<> <1D> <09><01>6<EFBFBD>A<EFBFBD>q<EFBFBD><14><03>8<EFBFBD><1C> <0B> <0B>A<EFBFBD><0E><1C>H<EFBFBD> <1D> <1D>s<00>(><00>,B<03>+B<03>>B<03>Bc#<00>hK<00>|jEd{<00><02><02>|jD] \}}|<01><01><00> y7<00><1D>wr
rb<00>rrfrgs r<00>__iter__z_UnhashDict.__iter__<5F>s4<00><00><><00><17>:<3A>:<3A><1D><1D><18>K<EFBFBD>K<EFBFBD> <14>D<EFBFBD>A<EFBFBD>q<EFBFBD><13>G<EFBFBD> <14> <1E>s <00>2<01>0<04>2N) rrrrrrnrqrtrwr rrr`r`<00>s <00><00><08><18> 1<><1C> <1C>rr`c<00><><00>eZdZdZefdd<03>d<04>Zd<05>Zd<06>Zd<07>Zd<08>Z e
jd <09>d
<EFBFBD>Z d <0B>Z d <0C>Zej dd <0A>d<0E><02>Zy)<0F>CallbackRegistrya<79>
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)<01>signalsc<00><><00>|<02>dn
t|<02>|_||_i|_t j
<00>|_tg<00>|_t<00>|_
yr
) <0B>list<73>_signals<6C>exception_handler<65> callbacks<6B> itertools<6C>count<6E>_cid_genr`<00> _func_cid_map<61>set<65> _pickled_cids)rr~rzs rrzCallbackRegistry.__init__sF<00><00> '<27><0F><04>T<EFBFBD>'<27>]<5D><04> <0A>!2<><04><1E><1B><04><0E>!<21><0F><0F>)<29><04> <0A>(<28><12>_<EFBFBD><04><1A> <20>U<EFBFBD><04>rc<00>4<00>it|<00><00>|jj<00>D<00><01><02><03>cic]=\}}||j<00>D<00><03>cic]\}}||jvr||<04><00><02>c}}<03><02>?c}}}}dt |j
<00>d<01><03>Scc}}wcc}}}}w)N)rr<>r<>)<06>varsr<00>itemsr<73><00>nextr<74>)r<00>s<>d<>cid<69>proxys r<00> __getstate__zCallbackRegistry.__getstate__ s<><00><00>

<EFBFBD><12>4<EFBFBD>j<EFBFBD>

<EFBFBD> '+<2B>n<EFBFBD>n<EFBFBD>&:<3A>&:<3A>&<<3C>><3E>><3E>"<22>a<EFBFBD><11><1C>Q<EFBFBD>W<EFBFBD>W<EFBFBD>Y<EFBFBD><<3C>z<EFBFBD>s<EFBFBD>E<EFBFBD>!$<24><04>(:<3A>(:<3A>!:<3A>"<22>5<EFBFBD>7<EFBFBD>l<EFBFBD><<3C><<3C>><3E>"<22><1C>T<EFBFBD>]<5D>]<5D>+<2B>

<EFBFBD>
<EFBFBD><EFBFBD><<3C><>>s<00>B <0C> B <16>(B <0C> B c<00>
<00>|jd<01>}t|<00>j|<01>|jj <00>D<00><03><04><05>cic]R\}}||j <00>D<00><05>cic]0\}}|t |t j|j|<03><00><00><02>2c}}<05><02>Tc}}}}|_td<02>|jj <00>D<00><00>|_
tj|<02>|_ ycc}}wcc}}}}w)Nr<4E>c3<00>^K<00>|]%\}}|j<00>D] \}}||f|f<02><01><00><00>'y<00>wr
)r<>)<05>.0r<EFBFBD>r<>r<>r<>s r<00> <genexpr>z0CallbackRegistry.__setstate__.<locals>.<genexpr> sE<00><00><><00>)L<01><14><01>1<EFBFBD><11><17><17><19>)L<01>3=<3D>3<EFBFBD><05><10><15>Z<EFBFBD><13> <1D>)L<01> <1D>)L<01>s<00>+-)rtr<><00>updaterr<>r^<00> functools<6C>partial<61> _remove_proxyr`r<>r<>r<>r<>)r<00>state<74> cid_countr<74>r<>r<>r\s r<00> __setstate__zCallbackRegistry.__setstate__s<><00><00><19>I<EFBFBD>I<EFBFBD>j<EFBFBD>)<29> <09> <0C>T<EFBFBD>
<EFBFBD><19><19>%<25> <20><1D><0E><0E>,<2C>,<2C>.<2E>0<>0<><15><01>1<EFBFBD> <0E>!"<22><17><17><19>,<2C><1D>C<EFBFBD><14><14>(<28><14>y<EFBFBD>/@<40>/@<40><14>AS<41>AS<41>UV<55>/W<>X<>X<>,<2C> ,<2C>0<><04><0E>)<29>)L<01><1C><0E><0E>,<2C>,<2C>.<2E>)L<01>L<01><04><1A>"<22><0F><0F> <09>2<><04> <0A><> ,<2C><>0s<00> C=
<EFBFBD>'5C7<14>C=
<EFBFBD>7C=
c<00><><00>|j<00>!tj|j|<01><01>t|t j
|j |<01><00>} |j||fS#t$rJt|j<00>x}|j||f<||jj|i<00>|<|cYSwxYw)z?Register *func* to be called when signal *signal* is generated.<2E><01>signal) r}r<00> check_in_listr^r<>r<>r<>r<>rpr<>r<>r<00>
setdefault)rr<>r\r<>r<>s r<00>connectzCallbackRegistry.connect%s<><00><00> <0F>=<3D>=<3D> $<24> <10> <1E> <1E>t<EFBFBD>}<7D>}<7D>V<EFBFBD> <<3C>#<23>D<EFBFBD>)<29>*;<3B>*;<3B>D<EFBFBD><N<><N<>PV<50>*W<>X<><05> <17><17>%<25>%<25>f<EFBFBD>e<EFBFBD>m<EFBFBD>4<> 4<><34><17> <17>6:<3A>4<EFBFBD>=<3D>=<3D>6I<36> I<>C<EFBFBD>$<24>$<24>$<24>V<EFBFBD>U<EFBFBD>]<5D>3<>9><3E>D<EFBFBD>N<EFBFBD>N<EFBFBD> %<25> %<25>f<EFBFBD>b<EFBFBD> 1<>#<23> 6<><16>J<EFBFBD> <17>s<00>A*<00>*AB=<03><B=c<00>`<00>|j||<02>}|jj|<03>|S)z{
Like `.connect`, but the callback is kept when pickling/unpickling.
Currently internal-use only.
)r<>r<><00>add)rr<>r\r<>s r<00>_connect_picklablez#CallbackRegistry._connect_picklable1s-<00><00> <13>l<EFBFBD>l<EFBFBD>6<EFBFBD>4<EFBFBD>(<28><03> <0C><1A><1A><1E><1E>s<EFBFBD>#<23><12>
r)<01>_is_finalizingc<00><00>|<03>ry|jj||fd<00>}|<04>,|j||=|jj |<04>nyt |j|<00>dk(r|j|=yyrs)r<>rtrr<><00>discard<72>len)rr<>r<>r<>r<>s rr<>zCallbackRegistry._remove_proxy=s{<00><00> <19> <1B> <12><12> <20> <20>$<24>$<24>f<EFBFBD>e<EFBFBD>_<EFBFBD>d<EFBFBD>;<3B><03> <0E>?<3F><14><0E><0E>v<EFBFBD>&<26>s<EFBFBD>+<2B> <10> <1E> <1E> &<26> &<26>s<EFBFBD> +<2B> <12> <0E>t<EFBFBD>~<7E>~<7E>f<EFBFBD>%<25> &<26>!<21> +<2B><14><0E><0E>v<EFBFBD>&<26> ,rc<00>j<00>|jj|<01>|jD]\}}|j||f|k(s<01>ny|j|||k(sJ<00>|j||=|jj ||f<02>t |j|<00>dk(r|j|=yy)z<>
Disconnect the callback registered with callback id *cid*.
No error is raised if such a callback does not exist.
Nr)r<>r<>r<>rrtr<>)rr<>r<>r<>s r<00>
disconnectzCallbackRegistry.disconnectJs<><00><00> <0A><1A><1A>"<22>"<22>3<EFBFBD>'<27>!<21>/<2F>/<2F> <13>M<EFBFBD>F<EFBFBD>E<EFBFBD><13>!<21>!<21>&<26>%<25>-<2D>0<>C<EFBFBD>7<><15> <13> <13><13>~<7E>~<7E>f<EFBFBD>%<25>c<EFBFBD>*<2A>e<EFBFBD>3<>3<>3<> <10>N<EFBFBD>N<EFBFBD>6<EFBFBD> "<22>3<EFBFBD> '<27> <0C><1A><1A><1E><1E><06><05><EFBFBD>/<2F> <0E>t<EFBFBD>~<7E>~<7E>f<EFBFBD>%<25> &<26>!<21> +<2B><14><0E><0E>v<EFBFBD>&<26> ,rc<00>^<00>|j<00>!tj|j|<01><02>t|jj |i<00>j <00><00>D]}|<04>}|<05><01> ||i|<03><01><00>y#t$r)}|j<00>|j|<06>n<01>Yd}~<06>Fd}~wwxYw)z<>
Process signal *s*.
All of the functions registered to receive callbacks on *s* will be
called with ``*args`` and ``**kwargs``.
Nr<4E>) r}rr<>r|rr/r;<00> Exceptionr~)rr<>r<00>kwargs<67>refr\rs r<00>processzCallbackRegistry.process\s<><00><00> <10>=<3D>=<3D> $<24> <10> <1E> <1E>t<EFBFBD>}<7D>}<7D>Q<EFBFBD> 7<><17><04><0E><0E>*<2A>*<2A>1<EFBFBD>b<EFBFBD>1<>8<>8<>:<3A>;<3B> <1E>C<EFBFBD><16>5<EFBFBD>D<EFBFBD><13><1F><1E><18>$<24>)<29>&<26>)<29> <1E><>!<21><1E><1B>-<2D>-<2D>9<><1C>.<2E>.<2E>s<EFBFBD>3<><1D>4<><34><1E>s<00>/A:<02>: B,<05>B'<05>'B,r<>c#<00><>K<00>|j} |<01>i|_n|D<00>cic]}||k7s<01> |||<00><02>c}|_d<01><02>||_ycc}w#||_wxYw<01>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.
N)r)rr<><00>origrfs r<00>blockedzCallbackRegistry.blockedrs^<00><00><><00><14>~<7E>~<7E><04> "<22><15>~<7E>!#<23><04><0E>7;<3B>!J<><11>a<EFBFBD>6<EFBFBD>k<EFBFBD>!<21>T<EFBFBD>!<21>W<EFBFBD>*<2A>!J<><04><0E> <11>!<21>D<EFBFBD>N<EFBFBD><4E>"K<01><>"<22>D<EFBFBD>N<EFBFBD>s0<00> A<01>A
<00>
A<04>A<04> A
<00>A<01>A
<00>
A<03>A)rrrrrHrr<>r<>r<>r<>r-<00> is_finalizingr<67>r<>r<><00>
contextlib<EFBFBD>contextmanagerr<72>r rrryry<00>se<00><00>6<08>x*<<3C>#<23><04>#<23> 
<EFBFBD>
3<>
<17><13>>A<01>=N<>=N<> '<27>'<27>$<1E>,<10><1E><1E> $<24>"<22><1F>"rryc<00><00>eZdZdZdd<03>Zd<04>Zy)<06> 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 ::
[<matplotlib.lines.Line2D object at 0x7f5749fed3c8>,
<matplotlib.lines.Line2D object at 0x7f5749fed4e0>,
<matplotlib.lines.Line2D object at 0x7f5758016550>]
one will get ::
<a list of 3 Line2D objects>
If ``self.type`` is None, the type name is obtained from the first item in
the list (if any).
Nc<00>:<00>||_|<02>|j|<02>yyr
)r<00>extend)rr<00>seqs rrzsilent_list.__init__<5F>s<00><00><18><04> <09> <0E>?<3F> <10>K<EFBFBD>K<EFBFBD><03> <1C> rc<00><><00>|j<00>t|<00>dk7rB|j<00> |jnt|d<00>j}dt|<00><00>d|<01>d<04>Sy)Nrz <a list of <20> z objects>z<an empty list>)rr<>r)r<00>tps r<00>__repr__zsilent_list.__repr__<5F>sT<00><00> <0F>9<EFBFBD>9<EFBFBD> <20>C<EFBFBD><04>I<EFBFBD><11>N<EFBFBD>"<22>i<EFBFBD>i<EFBFBD>3<><14><19><19><14>d<EFBFBD>1<EFBFBD>g<EFBFBD><1D>9O<39>9O<39>B<EFBFBD> <20><13>T<EFBFBD><19> <0B>1<EFBFBD>R<EFBFBD>D<EFBFBD> <09>:<3A> :<3A>$rr
)rrrrrr<>r rrr<>r<><00>s<00><00><08>(<1D>
%rr<>)<01> warning_clsc<00><><00>|}|D]6}|j|d<00>}|<06><01>|<04>|}<04>tjd|<05>d<02>|<02><00>8|S)N<>"z"" keyword argument will be ignored)rtr<00> warn_external)<07> local_varr<72>r<><00>keys<79>outrk<00> kwarg_vals r<00>_local_over_kwdictr<74><00>s\<00><00> <14>C<EFBFBD><13>0<><03><1A>J<EFBFBD>J<EFBFBD>s<EFBFBD>D<EFBFBD>)<29> <09> <14> <20><12>{<7B><1F><03><14>"<22>"<22>Q<EFBFBD>s<EFBFBD>e<EFBFBD>+M<>#N<>#.<2E>0<> 0<> <0F>Jrc<00><><00>t|<00>dk\r6|d|dcxk(rdk(r%n|S|dd}dD]\}}|j||<02>}<00>|S)zi
Remove latex formatting from mathtext.
Only handles fully math and fully non-math strings.
<20>r<00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>$<24>) )z\times<65>x)z \mathdefault<6C>)z\rmr<6D>)z\calr<6C>)z\ttr<74>)z\itr<74>)<02>\r<>)<02>{r<>)<02>}r<>)r<><00>replace)r<><00>tex<65>plains r<00>
strip_mathr<EFBFBD><00>se<00><00>  <0B>1<EFBFBD>v<EFBFBD><11>{<7B>q<EFBFBD><11>t<EFBFBD>q<EFBFBD><12>u<EFBFBD>+<2B><03>+<2B> <0A>H<EFBFBD> <0E>a<EFBFBD><02>G<EFBFBD><01>

<EFBFBD> &<26>J<EFBFBD>C<EFBFBD><15><12> <09> <09>#<23>u<EFBFBD>%<25>A<EFBFBD> &<26> <0A>Hrc<00>2<00>d} |jd|<01>}|jd|<01>}|dkr|dkr|n|d|}|j<00>Sd|cxkr|krnn|d|j<00>S|jd|dz<00>}|dkrtd|<00>d<07><03><00>|dz}<01><>)z+Strip everything from the first unquoted #.rr<><00>#Nr<4E>zMissing closing quote in: zM. If you need a double-quote inside a string, use escaping: e.g. "the " char")<03>find<6E>strip<69>
ValueError)r<><00>pos<6F> quote_pos<6F>hash_pos<6F>without_comment<6E>closing_quote_poss r<00>_strip_commentr<74><00>s<><00><00>
<0B>C<EFBFBD>
<0E><15>F<EFBFBD>F<EFBFBD>3<EFBFBD><03>$<24> <09><14>6<EFBFBD>6<EFBFBD>#<23>s<EFBFBD>#<23><08> <14>q<EFBFBD>=<3D>#+<2B>a<EFBFBD><<3C>a<EFBFBD>Q<EFBFBD>y<EFBFBD><08>\<5C>O<EFBFBD>"<22>(<28>(<28>*<2A> *<2A> <0E>(<28> &<26>Y<EFBFBD> &<26><14>Y<EFBFBD>h<EFBFBD><<3C>%<25>%<25>'<27> '<27> !<21><06><06>s<EFBFBD>I<EFBFBD><01>M<EFBFBD> :<3A> <1D> <20>1<EFBFBD>$<24> <20>0<><11><05>6N<01>N<01>O<01>O<01>$<24>a<EFBFBD>'<27>C<EFBFBD> rc<00>.<00>tt|dd<02><00>S)zDReturn whether *obj* looks like a file object with a *write* method.<2E>writeN)<02>callable<6C>getattr<74>rNs r<00>is_writable_file_liker<65><00>s<00><00> <13>G<EFBFBD>C<EFBFBD><17>$<24>/<2F> 0<>0rc<00>F<00> |jd<01>y#t$rYywxYw)zf
Return whether the given writable file-like object requires Unicode to be
written to it.
rFT)r<>r[<00>r<>s r<00>file_requires_unicoder<65><00>s+<00><00>
<15> <09><07><07><03> <0C><15><> <15><14><13><14>s <00><00> <03> Fc<00><><00>t|tj<00>rtj|<00>}t|t<00>ra|j d<01>rt j||<01>}n6|j d<02>rddl}|j||<01>}nt|||<03><05>}d}nt|d<07>r|}d}n td <09><00>|r||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.
<20>.gzz.bz2rN)<01>encodingT<67>seekFz'fname must be a PathLike or file handle) rR<00>os<6F>PathLike<6B>fspath<74>str<74>endswith<74>gzip<69>open<65>bz2<7A>BZ2File<6C>hasattrr<72>)<07>fname<6D>flag<61> return_openedr<64><00>fhr<68><00>openeds r<00> to_filehandler<65><00>s<><00><00>:<12>%<25><12><1B><1B>%<25><12> <09> <09>%<25> <20><05><11>%<25><13><1D> <10>><3E>><3E>%<25> <20><15><19><19>5<EFBFBD>$<24>'<27>B<EFBFBD> <12>^<5E>^<5E>F<EFBFBD> #<23> <17><14><1B><1B>U<EFBFBD>D<EFBFBD>)<29>B<EFBFBD><15>e<EFBFBD>T<EFBFBD>H<EFBFBD>5<>B<EFBFBD><15><06> <10><15><06> <1F> <12><02><16><06><18>B<>C<>C<><14><11>6<EFBFBD>z<EFBFBD><19> <0A>Irc<00>V<00>t||d|<02>\}}|r|Stj|<03>S)z8Pass through file objects and context-manage path-likes.T)r<>r<><00> nullcontext)<05> path_or_file<6C>moder<65>r<>r<>s r<00> open_file_cmr.s.<00><00><1E>|<7C>T<EFBFBD>4<EFBFBD><18>B<>J<EFBFBD>B<EFBFBD><06><17>2<EFBFBD>7<>Z<EFBFBD>3<>3<>B<EFBFBD>7<>7rc<00>R<00>t|t<00>xstj|<00> S)z;Return whether the given object is a scalar or string like.)rRr<><00>np<6E>iterable<6C><01>vals r<00>is_scalar_or_stringr4s <00><00> <15>c<EFBFBD>3<EFBFBD> <1F> 7<>r<EFBFBD>{<7B>{<7B>3<EFBFBD>'7<>#7<>7rc<00><00>td|<00>}|rs|jj<00>}|dk(rtj|<02>S|dvrt j |<02>S|dvr|j d<05>S|j d<06>St|<02>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`.
<20> sample_datar<61>)z.npyz.npz)z.csvz.xrcz.txt<78>r<>rb)<08>_get_data_path<74>suffix<69>lowerr<72>r<>r<00>loadr<64>)r<><00> asfileobj<62>pathr s r<00>get_sample_datar9s<><00><00> <1A>-<2D><15> /<2F>D<EFBFBD><10><15><1B><1B>"<22>"<22>$<24><06> <11>U<EFBFBD>?<3F><17>9<EFBFBD>9<EFBFBD>T<EFBFBD>?<3F> "<22> <13>'<27> '<27><15>7<EFBFBD>7<EFBFBD>4<EFBFBD>=<3D> <20> <13>/<2F> /<2F><17>9<EFBFBD>9<EFBFBD>S<EFBFBD>><3E> !<21><17>9<EFBFBD>9<EFBFBD>T<EFBFBD>?<3F> "<22><12>4<EFBFBD>y<EFBFBD>rc<00>><00>ttj<00>g|<00><01><06>S)z<>
Return the `pathlib.Path` to a resource file provided by Matplotlib.
``*args`` specify a path relative to the base data path.
)r<00>
matplotlib<EFBFBD> get_data_path)rs rr r Us<00><00> <10>
<EFBFBD>(<28>(<28>*<2A> 2<>T<EFBFBD> 2<>2rc#<00>dK<00>|D]%}||<02>s|<02>|<02><01><00>t||<01>Ed{<00><02><02><00>'y7<00><07>w)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)<01>flatten)r<><00>scalarp<72>items rrr^s<<00><00><><00><14>.<2E><04> <12>4<EFBFBD>=<3D>D<EFBFBD>L<EFBFBD><16>J<EFBFBD><1E>t<EFBFBD>W<EFBFBD>-<2D> -<2D> -<2D> .<2E> .<2E>s <00>$0<01>.<06>0c<00>F<00>eZdZdZd<02>Zd<03>Zd<04>Zd<05>Zd<06>Zd<07>Z d<08>Z
d <09>Z d
<EFBFBD>Z y ) <0C>_Stackzb
Stack of elements with a movable cursor.
Mimics home/back/forward in a web browser.
c<00> <00>d|_g|_y)Nr<4E><00><02>_pos<6F> _elementsrs rrz_Stack.__init__{s<00><00><16><04> <09><1B><04>rc<00> <00>d|_g|_y)zEmpty the stack.r<>Nrrs r<00>clearz _Stack.clears<00><00><16><04> <09><1B><04>rc<00>P<00>|jr|j|jSdS)z$Return the current element, or None.N)rrrs rrPz_Stack.__call__<5F>s <00><00>,0<>N<EFBFBD>N<EFBFBD>t<EFBFBD>~<7E>~<7E>d<EFBFBD>i<EFBFBD>i<EFBFBD>(<28>D<><04>Drc<00>,<00>t|j<00>Sr
)r<>rrs r<00>__len__z_Stack.__len__<5F>s<00><00><12>4<EFBFBD>><3E>><3E>"<22>"rc<00> <00>|j|Sr
)r)r<00>inds rrqz_Stack.__getitem__<5F>s<00><00><13>~<7E>~<7E>c<EFBFBD>"<22>"rc<00>x<00>t|jdzt|j<00>dz
<00>|_|<00>S)z9Move the position forward and return the current element.r<>)<04>minrr<>rrs r<00>forwardz_Stack.forward<72>s-<00><00><17><04> <09> <09>A<EFBFBD> <0A>s<EFBFBD>4<EFBFBD>><3E>><3E>':<3A>Q<EFBFBD>'><3E>?<3F><04> <09><13>v<EFBFBD> rc<00>L<00>t|jdz
d<02>|_|<00>S)z6Move the position back and return the current element.r<>r)<02>maxrrs r<00>backz _Stack.back<63>s<00><00><17><04> <09> <09>A<EFBFBD> <0A>q<EFBFBD>)<29><04> <09><13>v<EFBFBD> rc<00>z<00>|g|j|jdzdt|j<00>dz
|_|S)zx
Push *o* to the stack after the current position, and return *o*.
Discard all later elements.
r<>N)rrr<>)r<00>os r<00>pushz _Stack.push<73>s8<00><00> +,<2C><13><04><0E><0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>1<EFBFBD>}<7D>~<7E>&<26><17><04><0E><0E>'<27>!<21>+<2B><04> <09><10>rc<00>Z<00>|jr|j|jd<00>SdS)zk
Push the first element onto the top of the stack.
The first element is returned.
rN)rr.rs r<00>homez _Stack.home<6D>s'<00><00> 04<30>~<7E>~<7E>t<EFBFBD>y<EFBFBD>y<EFBFBD><14><1E><1E><01>*<2A>+<2B>G<>4<EFBFBD>GrN) rrrrrr rPr#rqr(r+r.r0r rrrrts6<00><00><08> <1C><1C>
E<01>#<23>#<23><16>
<16>
<11>Hrrc<00>f<00>tj|d|<01><02>}|jjs:|j |<01><03>j |jj d<04><00>} tjjtj|<00>|d<05><06>}|S#t$r|cYSwxYw)NT)<02>subok<6F>copy)<01>inplace<63>NF)r3) r<00>array<61>dtype<70>isnative<76>byteswap<61>view<65> newbyteorder<65>ma<6D> masked_where<72>isfiniter[)r<>r3<00>xms r<00>safe_masked_invalidr@<00>s<><00><00>
<EFBFBD><08><08><11>$<24>T<EFBFBD>*<2A>A<EFBFBD> <0C>7<EFBFBD>7<EFBFBD> <1B> <1B> <0E>J<EFBFBD>J<EFBFBD>t<EFBFBD>J<EFBFBD> $<24> )<29> )<29>!<21>'<27>'<27>*><3E>*><3E>s<EFBFBD>*C<> D<><01><11> <0F>U<EFBFBD>U<EFBFBD> <1F> <1F>"<22>+<2B>+<2B>a<EFBFBD>.<2E> 1<>1<EFBFBD>5<EFBFBD> <1F> A<><02> <0E>I<EFBFBD><49> <15><11><10><08><11>s<00>*6B"<00>" B0<03>/B0c<00><><00><00><01><02><04><05><06>ddl<00><04>fd<03><08><05><04><00><01><05><06>fd<04><08><06>D]"}<03>jd|<03>d<06><03><00>||ig<00><00>$y)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<00>r<00><01>t|<00>D<00>]\}}||dzt|<00>z}<03>jdt|<02>z<00>t |t
<00>rN|j <00>D]:\}}||ur<17>jd|<04>d<04><03>n<>||us<01>&<26>jd|<05><02><02>nrnpt |t<00>r$<24>jd|j|<03>z<00>n<t |t<00>r<12>jd<07>n<1A>jt|<02><00><00>jd<08><00><01><00>jd <09>y)
Nr<EFBFBD>z %s -- <20>[<5B>]z[key] = z[%d]z ( tuple )z ->
<EFBFBD>
) rir<>r<>rrR<00>dictr<74>r|<00>index<65>tuple<6C>repr)rrm<00>stepr<70>rkr<00> outstreams <20>r<00>
print_pathz print_cycles.<locals>.print_path<74>s
<00><><00> <20><14><EFBFBD> %<25>G<EFBFBD>A<EFBFBD>t<EFBFBD><17><11>Q<EFBFBD><15>#<23>d<EFBFBD>)<29>+<2B>,<2C>D<EFBFBD> <15>O<EFBFBD>O<EFBFBD>K<EFBFBD>$<24>t<EFBFBD>*<2A>4<> 5<><19>$<24><04>%<25> $<24>
<EFBFBD>
<EFBFBD> <0C><1E>H<EFBFBD>C<EFBFBD><13><1A>d<EFBFBD>{<7B>!<21><0F><0F>!<21>C<EFBFBD>7<EFBFBD>!<21> <0C>5<><1D><1A>d<EFBFBD>{<7B>!<21><0F><0F>(<28>3<EFBFBD>'<27>(:<3A>;<3B><1D> <1E><1C>D<EFBFBD>$<24>'<27><19><0F><0F><06><14><1A><1A>D<EFBFBD>)9<> 9<>:<3A><1B>D<EFBFBD>%<25>(<28><19><0F><0F> <0B>,<2C><19><0F><0F><04>T<EFBFBD>
<EFBFBD>+<2B> <15>O<EFBFBD>O<EFBFBD>G<EFBFBD> $<24>' %<25>( <12><0F><0F><04>rc<00>"<00><06><00> r<1D>jdt|<02>z<00>d|t|<00><<00>j|<00>}|D]K}||ur <00> |<03><00>|<05>ust |t
j <00>r<01>/t|<05>|vs<01>=<00>
|||||gz<00><00>My)Nz%d )r<>r<><00>id<69> get_referentsrR<00>types<65> FrameType) rN<00>start<72>all<6C> current_path<74> referents<74>referent<6E>gc<67>objectsrKrL<00>recurse<73> show_progresss <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>rrYzprint_cycles.<locals>.recurse<73>s<><00><><00> <18> <15>O<EFBFBD>O<EFBFBD>F<EFBFBD>S<EFBFBD><13>X<EFBFBD>-<2D> .<2E><1B><03>B<EFBFBD>s<EFBFBD>G<EFBFBD> <0C><16>$<24>$<24>S<EFBFBD>)<29> <09>!<21> D<01>H<EFBFBD><18>5<EFBFBD> <20><1A><<3C>(<28>
<1A>W<EFBFBD>$<24>
<EFBFBD>8<EFBFBD>U<EFBFBD>_<EFBFBD>_<EFBFBD>(M<><18><14>H<EFBFBD><1C>S<EFBFBD>(<28><17><08>%<25><13>l<EFBFBD>c<EFBFBD>U<EFBFBD>.B<>C<> Drz Examining: rE)rWr<>)rXrKrZrNrWrLrYs``` @@@r<00> print_cyclesr[<00>sM<00><><00> <0E><1E>.D<01>D<01>.<17>"<22><03><11><0F><0F>+<2B>c<EFBFBD>W<EFBFBD>B<EFBFBD>/<2F>0<><0F><03>S<EFBFBD>"<22>b<EFBFBD>!<21>"rc<00>H<00>eZdZdZd d<02>Zd<03>Zd<04>Zd<05>Zd<06>Zd<07>Z d<08>Z
d <09>Z d
<EFBFBD>Z y ) <0A>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
c <00>^<00>tj|D<00>cic]}|tj|g<01><00><02>c}<02>|_tj<00>|_|D]3}||jvs<01>t |j<00>|j|<<00>5t |j<00>|_ycc}wr
)rY<00>WeakKeyDictionary<72>WeakSet<65>_mapping<6E> _orderingr<67><00> _next_order)r<00>initr<74>s rrzGrouper.__init__ s<><00><00><1F>1<>1<>.2<EFBFBD> 3<><11>Q<EFBFBD><07><0F><0F><11><03>$<24> $<24> 3<>5<><04> <0A> <20>2<>2<>4<><04><0E><15> 8<>A<EFBFBD><10><04><0E><0E>&<26>$'<27><04><0E><0E>$7<><04><0E><0E>q<EFBFBD>!<21> 8<><1F>t<EFBFBD>~<7E>~<7E>.<2E><04><18><> 4s<00>B*c <00><><00>it|<00><00>|jj<00>D<00><01>cic]\}}|t|<02><00><02>c}}i|j<00>d<01><02>Scc}}w)N)rarb)r<>rar<>r<>rbrvs rr<>zGrouper.__getstate__)sX<00><00>
<EFBFBD><12>4<EFBFBD>j<EFBFBD>
<EFBFBD>04<30>}<7D>}<7D>/B<>/B<>/D<>E<>t<EFBFBD>q<EFBFBD>!<21><11>C<EFBFBD><01>F<EFBFBD><19>E<>+<2B>D<EFBFBD>N<EFBFBD>N<EFBFBD>+<2B> 
<EFBFBD>
<EFBFBD><EFBFBD>Fs<00>Ac
<00>><00>t|<00>j|<01>tj|jj <00>D<00><02>cic]\}}|tj |<03><00><02>c}}<02>|_tj|j<00>|_ycc}}wr
)r<>r<>rYr_rar<>r`rb)rr<>rfrgs rr<>zGrouper.__setstate__1sp<00><00> <0C>T<EFBFBD>
<EFBFBD><19><19>%<25> <20><1F>1<>1<>/3<>}<7D>}<7D>/B<>/B<>/D<> E<>t<EFBFBD>q<EFBFBD>!<21>Q<EFBFBD><07><0F><0F><01>"<22> "<22> E<>G<01><04> <0A> <20>2<>2<>4<EFBFBD>><3E>><3E>B<><04><0E><> Fs<00> B
c<00><00>||jvSr
)ra<00>rrs r<00> __contains__zGrouper.__contains__8s<00><00><13>t<EFBFBD>}<7D>}<7D>$<24>$rc<00><00>|j} ||}|D]E} ||}||us<01>t |<06>t |<04>kDr||}}|j|<06>|D]}|||<<00> <00>Gy#t$rLtj|g<01>x}||<|j|j
|<|xjdz c_Y<00><>wxYw#t$rLtj|g<01>x}||<|j|j
|<|xjdz c_Y<00><>wxYw)zY
Join given arguments into the same set. Accepts one or more arguments.
r<>N)rarprYr`rcrbr<>r<>)r<00>ar<00>mapping<6E>set_a<5F>arg<72>set_b<5F>elems r<00>joinz Grouper.join;s<00><00><17>-<2D>-<2D><07> "<22><1B>A<EFBFBD>J<EFBFBD>E<EFBFBD>
<18> *<2A>C<EFBFBD> &<26><1F><03> <0C><05>
<15>E<EFBFBD>!<21><16>u<EFBFBD>:<3A><03>E<EFBFBD>
<EFBFBD>*<2A>#(<28>%<25>5<EFBFBD>E<EFBFBD><15> <0C> <0C>U<EFBFBD>#<23>!<21>*<2A>D<EFBFBD>$)<29>G<EFBFBD>D<EFBFBD>M<EFBFBD>*<2A> *<2A><> <18> "<22>!(<28><1F><1F>!<21><13>!5<> 5<>E<EFBFBD>G<EFBFBD>A<EFBFBD>J<EFBFBD> $<24> 0<> 0<>D<EFBFBD>N<EFBFBD>N<EFBFBD>1<EFBFBD> <1D> <10> <1C> <1C><01> !<21> <1C> "<22><><1C> &<26>'.<2E><EFBFBD><EFBFBD><03>u<EFBFBD>'=<3D>=<3D><05><07><03> <0C>&*<2A>&6<>&6<><04><0E><0E>s<EFBFBD>#<23><14> <20> <20>A<EFBFBD>%<25> <20> &<26>s$<00>A<00>B6<02>AB3<03>2B3<03>6AD <05>
D c<00><><00>|jj|t<00><00>|jj|<02>uS)z7Return whether *a* and *b* are members of the same set.)rar/<00>object<63>rrk<00>bs r<00>joinedzGrouper.joinedTs/<00><00><14> <0A> <0A>!<21>!<21>!<21>V<EFBFBD>X<EFBFBD>.<2E>$<24>-<2D>-<2D>2C<32>2C<32>A<EFBFBD>2F<32>F<>Grc<00><><00>|jj||h<01>j|<01>|jj|d<01>y)z>Remove *a* from the grouper, doing nothing if it is not there.N)rart<00>removerb<00>rrks rrxzGrouper.removeXs7<00><00> <0C> <0A> <0A><19><19>!<21>a<EFBFBD>S<EFBFBD>!<21>(<28>(<28><11>+<2B> <0C><0E><0E><1A><1A>1<EFBFBD>d<EFBFBD>#rc#<00><>K<00>|jj<00>D<00>cic]}t|<01>|<01><02>}}|j<00>D]%}t||jj
<00><01><00><01><00>'ycc}w<00>w)z<>
Iterate over each of the disjoint sets as a list.
The iterator is invalid if interleaved with calls to join().
<20>rkN)rar;rN<00>sortedrbrq)r<00>group<75> unique_groupss rrwzGrouper.__iter__]sh<00><00><><00> 8<<3C>}<7D>}<7D>7K<37>7K<37>7M<37>N<>e<EFBFBD><12>E<EFBFBD><19>E<EFBFBD>)<29>N<> <0A>N<>"<22>)<29>)<29>+<2B> @<01>E<EFBFBD><18><15>D<EFBFBD>N<EFBFBD>N<EFBFBD>$><3E>$><3E>?<3F> ?<3F> @<01><>O<01>s<00>A2<01>A-<04>AA2c<00>~<00>|jj||g<01>}t||jj<00><01>S)z:Return all of the items joined with *a*, including itself.r{)rar/r|rb)rrk<00>siblingss r<00> get_siblingszGrouper.get_siblingsgs1<00><00><17>=<3D>=<3D>$<24>$<24>Q<EFBFBD><11><03>,<2C><08><15>h<EFBFBD>D<EFBFBD>N<EFBFBD>N<EFBFBD>$6<>$6<>7<>7rN)r ) rrrrrr<>r<>rirqrvrxrwr<>r rrr]r]<00>s8<00><00><08>B/<2F>
<EFBFBD>C<01>%<25>*<2A>2H<01>$<24>
@<01>8rr]c<00>.<00>eZdZdZd<02>Zd<03>Zd<04>Zd<05>Zd<06>Zy)<08> GrouperViewz!Immutable view over a `.Grouper`.c<00><00>||_yr
<00><01>_grouper)r<00>groupers rrzGrouperView.__init__ps<00><00><17><14>rc<00><00>||jvSr
r<>rhs rrizGrouperView.__contains__qs<00><00><14><14><1D><1D>)><3E>">rc<00>,<00>t|j<00>Sr
)<02>iterr<72>rs rrwzGrouperView.__iter__rs<00><00>t<EFBFBD>D<EFBFBD>M<EFBFBD>M<EFBFBD>2<>2rc<00>:<00>|jj||<02>S)zI
Return whether *a* and *b* are members of the same set.
)r<>rvrts rrvzGrouperView.joinedts<00><00><14>}<7D>}<7D>#<23>#<23>A<EFBFBD>q<EFBFBD>)<29>)rc<00>8<00>|jj|<01>S)zL
Return all of the items joined with *a*, including itself.
)r<>r<>rys rr<>zGrouperView.get_siblingszs<00><00><14>}<7D>}<7D>)<29>)<29>!<21>,<2C>,rN) rrrrrrirwrvr<>r rrr<>r<>ms<00><00>+<2B>8<>><3E>2<>*<2A> -rr<>c
<00><><00>|jt|<00>df<02>}tjt|<00><00>|z}tjt|<00>dz
|zdz<00>}tj|j
D<00>cgc]}tj |||<05><00><02>c}<05>jt|<04>f|jddz<00>Scc}w)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, ...)``
r<>r<>N)<08>reshaper<65>r<00>arange<67> column_stack<63>T<>interp<72>shape)rk<00>steps<70>fps<70>xpr<70><00>fps r<00>simple_linear_interpolationr<6E><00>s<><00><00>" <0C>)<29>)<29>S<EFBFBD><11>V<EFBFBD>R<EFBFBD>L<EFBFBD>
!<21>C<EFBFBD> <0B><19><19>3<EFBFBD>q<EFBFBD>6<EFBFBD> <1A>U<EFBFBD> "<22>B<EFBFBD>
<EFBFBD> <09> <09>3<EFBFBD>q<EFBFBD>6<EFBFBD>A<EFBFBD>:<3A><15>&<26><11>*<2A>+<2B>A<EFBFBD> <0E>O<EFBFBD>O<EFBFBD>C<EFBFBD>E<EFBFBD>E<EFBFBD>B<>b<EFBFBD>R<EFBFBD>Y<EFBFBD>Y<EFBFBD>q<EFBFBD>"<22>b<EFBFBD>1<>B<> C<> <14>W<EFBFBD>c<EFBFBD>!<21>f<EFBFBD>Y<EFBFBD><11><17><17><11><12><1B>,<2C> -<2D>/<2F><>Bs<00>Cc<00>"<00>t|<00>syt|d<00>r td<03><00>t|d<00>}g}dgt|<00>z}t|<00>D]<5D>\}}t |t
<00>s{t j|<05>rft|<05>|k(rXd||<t |t jj<00>r|jdkDr td<07><00>t j|<05>}|j|<05><00><>g}t|<02>D]<5D>\}}||s<01> |jdkDr<01>t |t jj<00>r<|jt jj|<05><00>|j}n|} t j|<07>}t |t j <00>r|j|<08><00><>t|<06>rat j$j'|<06>}|j)<00>d} t| <09>|kr!t|<02>D]\}}||s<01> || ||<<00>t|<02>D]C\}}||s<01> t |t jj<00>s<01>1|j+<00>||<<00>E|S#t"$rY<00><01><>wxYw)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().
r r<00>!First argument must be a sequenceFTr<54><00>Masked arrays must be 1-D)r<>rr<>rirRr<>rrr<<00> MaskedArray<61>ndim<69>asarrayrj<00> getmaskarray<61>datar><00>ndarrayr<79><00> logical_and<6E>reduce<63>nonzero<72>filled)
r<00>nrecs<63>margs<67>seqlistrmr<><00>masks<6B>xd<78>mask<73>igoods
r<00>delete_masked_pointsr<73><00>s.<00><00>@ <0F>t<EFBFBD>9<EFBFBD><11><1A>4<EFBFBD><01>7<EFBFBD>#<23><18><<3C>=<3D>=<3D> <0F><04>Q<EFBFBD><07>L<EFBFBD>E<EFBFBD> <0E>E<EFBFBD><14>g<EFBFBD><03>D<EFBFBD> <09>!<21>G<EFBFBD><19>$<24><0F><18><04><01>1<EFBFBD><19>!<21>S<EFBFBD>!<21>b<EFBFBD>k<EFBFBD>k<EFBFBD>!<21>n<EFBFBD><13>Q<EFBFBD><16>5<EFBFBD><1F><1D>G<EFBFBD>A<EFBFBD>J<EFBFBD><19>!<21>R<EFBFBD>U<EFBFBD>U<EFBFBD>.<2E>.<2E>/<2F><14>6<EFBFBD>6<EFBFBD>A<EFBFBD>:<3A>$<24>%@<40>A<>A<><16>J<EFBFBD>J<EFBFBD>q<EFBFBD>M<EFBFBD><01> <0A> <0C> <0C>Q<EFBFBD><0F><18> <0F>E<EFBFBD><19>%<25> <20><15><04><01>1<EFBFBD> <12>1<EFBFBD>:<3A><10>v<EFBFBD>v<EFBFBD><01>z<EFBFBD><18><19>!<21>R<EFBFBD>U<EFBFBD>U<EFBFBD>.<2E>.<2E>/<2F><15> <0C> <0C>b<EFBFBD>e<EFBFBD>e<EFBFBD>0<>0<><11>3<>3<>4<><16>V<EFBFBD>V<EFBFBD><02><16><02> <15><19>{<7B>{<7B>2<EFBFBD><EFBFBD><04><1D>d<EFBFBD>B<EFBFBD>J<EFBFBD>J<EFBFBD>/<2F><19>L<EFBFBD>L<EFBFBD><14>&<26><><15> <0B>5<EFBFBD>z<EFBFBD><11>~<7E>~<7E>$<24>$<24>U<EFBFBD>+<2B><04><14> <0C> <0C><0E>q<EFBFBD>!<21><05> <0E>u<EFBFBD>:<3A><05> <1D>!<21>%<25>(<28> (<28><04><01>1<EFBFBD><1A>1<EFBFBD>:<3A> <20><15>x<EFBFBD>E<EFBFBD>!<21>H<EFBFBD> (<28><1A>%<25> <20>"<22><04><01>1<EFBFBD> <12>1<EFBFBD>:<3A>*<2A>Q<EFBFBD><02><05><05>(9<>(9<>:<3A><18>x<EFBFBD>x<EFBFBD>z<EFBFBD>E<EFBFBD>!<21>H<EFBFBD>"<22> <11>L<EFBFBD><4C><1D> <15><14> <15>s<00>AJ<02> J<05> Jc<00><><00>t|<00>syt|d<00>r td<03><00>t|d<00>}g}dgt|<00>z}g}t|<00>D<00>]\}}t|<06>st|<06>|k7r|j |<06><00>2t |t jj<00>r|jdkDr td<06><00> t j|<06>}|jdk(r]t|<06>}d||<t jj|<06>r.|j t jj|<06><00>|j |<06><00><01>t|<04>r\t j j#|<04>}t|<02>D]/\}}||s<01> t jj%||<07> <09>||<<00>1|S#ttf$rt j|t<00><07>}Y<00><01>wxYw)
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.
r rr<>Fr<46>r<><00>r7T<>r<>)r<>rr<>rirjrRrr<r<>r<><00>
asanyarrayrrsr@<00> is_maskedr<64><00>
logical_orr<EFBFBD>r6)rr<>r<>r<>r<>rmr<>r<>s r<00>_combine_masksr<73><00>s<><00><00>> <0F>t<EFBFBD>9<EFBFBD><11><1A>4<EFBFBD><01>7<EFBFBD>#<23><18><<3C>=<3D>=<3D> <0F><04>Q<EFBFBD><07>L<EFBFBD>E<EFBFBD> <0E>E<EFBFBD><14>g<EFBFBD><03>D<EFBFBD> <09>!<21>G<EFBFBD> <0E>E<EFBFBD><19>$<24><0F><1C><04><01>1<EFBFBD> <1E>q<EFBFBD> !<21>S<EFBFBD><11>V<EFBFBD>u<EFBFBD>_<EFBFBD> <11>L<EFBFBD>L<EFBFBD><11>O<EFBFBD><19>!<21>R<EFBFBD>U<EFBFBD>U<EFBFBD>.<2E>.<2E>/<2F>A<EFBFBD>F<EFBFBD>F<EFBFBD>Q<EFBFBD>J<EFBFBD> <20>!<<3C>=<3D>=<3D> 3<><16>M<EFBFBD>M<EFBFBD>!<21>$<24><01>
<11>v<EFBFBD>v<EFBFBD><11>{<7B>'<27><01>*<2A><01>!<21><07><01>
<EFBFBD><15>5<EFBFBD>5<EFBFBD>?<3F>?<3F>1<EFBFBD>%<25><19>L<EFBFBD>L<EFBFBD><12><15><15>!3<>!3<>A<EFBFBD>!6<>7<> <11>L<EFBFBD>L<EFBFBD><11>O<EFBFBD>#<1C>$ <0B>5<EFBFBD>z<EFBFBD><11>}<7D>}<7D>#<23>#<23>E<EFBFBD>*<2A><04><1D>e<EFBFBD>$<24> 5<>D<EFBFBD>A<EFBFBD>q<EFBFBD><16>q<EFBFBD>z<EFBFBD><1D>5<EFBFBD>5<EFBFBD>;<3B>;<3B>q<EFBFBD>t<EFBFBD>;<3B>4<><05>a<EFBFBD><08> 5<> <11>L<EFBFBD><4C>.<2E>z<EFBFBD>:<3A> 3<><17>M<EFBFBD>M<EFBFBD>!<21>6<EFBFBD>2<><01> 3<>s<00>G<02>*G/<05>.G/)<01>compressc<00><><00>|D<00>cgc]3}t|tjj<00>s<01>(|j<00><02>5}}tj
g|<01>|<03><01><06>}|dt |<01>}|t |<01>d}|r<>tjj|<03>}|r>|D<00>cgc]1}tjj||<06><02>j<00><00><02>3}}|S|D<00>cgc]S}tjj||t<00><03>jtj<00>j<00><00><02>U}}|S|D<00>cgc]}tj|<02><00><02>}}|Scc}wcc}wcc}wcc}w)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.
Nr<4E>)r<>r7)rRrr<r<>r<><00>broadcast_arraysr<73>r<>r<>r6<00>
compressed<EFBFBD>floatr<74><00>nan<61>ravel)r<>rrfr<><00>bcast<73>inputsr<73>s r<00>_broadcast_with_masksr<73>'sF<00><00>$"<22> F<><01>Z<EFBFBD><01>2<EFBFBD>5<EFBFBD>5<EFBFBD>3D<33>3D<33>%E<>Q<EFBFBD>V<EFBFBD>V<EFBFBD> F<>E<EFBFBD> F<> <0E> <1F> <1F> .<2E><14> .<2E><05> .<2E>E<EFBFBD> <12>:<3A>C<EFBFBD><04>I<EFBFBD> <1E>F<EFBFBD> <11>#<23>d<EFBFBD>)<29>*<2A> <1D>E<EFBFBD> <0C><11>}<7D>}<7D>#<23>#<23>E<EFBFBD>*<2A><04> <13>%<25>'<27><1B><19>e<EFBFBD>e<EFBFBD>k<EFBFBD>k<EFBFBD>!<21>$<24>k<EFBFBD>/<2F>:<3A>:<3A><<3C>'<27>F<EFBFBD>'<27> <12>M<EFBFBD> &<26>'<27><1B><19>e<EFBFBD>e<EFBFBD>k<EFBFBD>k<EFBFBD>!<21>$<24>e<EFBFBD>k<EFBFBD><<3C>C<>C<>B<EFBFBD>F<EFBFBD>F<EFBFBD>K<>Q<>Q<>S<>'<27>F<EFBFBD>'<27> <12>M<EFBFBD>(.<2E>.<2E>!<21>"<22>(<28>(<28>1<EFBFBD>+<2B>.<2E><06>.<2E> <11>M<EFBFBD><4D># G<01><>'<27><>'<27><>/s<00>)E<04>E<04>6E<04>AE!<04>7E&c<00><><00><14>dd<01><01><14>fd<02>}g}t|d<03>}t|<00>}|<03>tjd<04>}nt|<03>|k7r t d<05><00>|}t t ||<03><00>D<00>]<5D>\} \}
} i} | <0B>| | d<|}|j| <0C>t|
<EFBFBD>dk(r<>tjg<00>| d<tj| d <tj| d
<tj| d <tj| d <tj| d <tj| d<tj| d<tj| d<tj| d<<00><>tjj|
<EFBFBD>}
|
j|
jj<00>}
tj |
<EFBFBD>| d <tj"|
gd<12><01>\} }}|| z
| d <| d dk(r|rd}||
|| d |<02>\| d<| d<tj$|<01>r*t'|t(<00>stj"|
|<01>\}}n7tj*|<01>r| || d zz
}||| d zz}n t d<14><00>|
|
|k}t|<12>dk(stj,|<12>|kr|| d<ntj,|<12>| d<|
|
|k\}t|<13>dk(stj.|<13>| kDr| | d<ntj.|<13>| d<tj0|
|
| dk|
|
| dkDg<02>| d<| ||c| d <| d
<| d <<00><02><>|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.
c<00><><00>t|<00>}ddg}tjj|||f<02><03>}||}tj|dd<05><06>}tj
||<03>}|S)Ng@g`X@)<01>sizer<65>T)<02>axis<69>overwrite_input)r<>r<00>random<6F>randint<6E>median<61>
percentile)r<>r5<00>M<> percentiles<65>bs_index<65>bsData<74>estimate<74>CIs r<00>_bootstrap_medianz(boxplot_stats.<locals>._bootstrap_median<61>sa<00><00> <0F><04>I<EFBFBD><01><1A>D<EFBFBD>k<EFBFBD> <0B><15>9<EFBFBD>9<EFBFBD>$<24>$<24>Q<EFBFBD>a<EFBFBD><11>V<EFBFBD>$<24>4<><08><15>h<EFBFBD><1E><06><15>9<EFBFBD>9<EFBFBD>V<EFBFBD>!<21>T<EFBFBD>B<><08> <0F>]<5D>]<5D>8<EFBFBD>[<5B> 1<><02><11> rc<00><><00><01>|<03><00>||<03><01>}|d}|d}||fSt|<00>}|d|ztj|<07>z z
}|d|ztj|<07>z z}||fS)N)r5rr<>g<1F><>Q<EFBFBD><1E>?)r<>r<00>sqrt) r<><00>med<65>iqr<71> bootstrapr<70><00> notch_min<69> notch_maxr5r<>s <20>r<00>_compute_conf_intervalz-boxplot_stats.<locals>._compute_conf_interval<61>s<><00><><00> <14> <20>#<23>4<EFBFBD>9<EFBFBD>5<>B<EFBFBD><1A>1<EFBFBD><05>I<EFBFBD><1A>1<EFBFBD><05>I<EFBFBD><19>)<29>#<23>#<23> <14>D<EFBFBD> <09>A<EFBFBD><1B>d<EFBFBD>S<EFBFBD>j<EFBFBD>2<EFBFBD>7<EFBFBD>7<EFBFBD>1<EFBFBD>:<3A>5<>5<>I<EFBFBD><1B>d<EFBFBD>S<EFBFBD>j<EFBFBD>2<EFBFBD>7<EFBFBD>7<EFBFBD>1<EFBFBD>:<3A>5<>5<>I<EFBFBD><18>)<29>#<23>#r<00>XNz-Dimensions of labels and X must be compatible<6C>labelr<00>fliers<72>meanr<6E><00>q1<71>q3r<33><00>cilo<6C>cihi<68>whislo<6C>whishi)<03><00>2<00>K)r<00>dz+whis must be a float or list of percentiles)i<>)<19> _reshape_2Dr<44>r<><00>repeatr<74>ri<00>ziprjrr6r<>r<r<>r<>r<>r<>r<>r<>rrRr<><00>isrealr*r'<00> concatenate)r<><00>whisr<73><00>labels<6C> autoranger<65><00>bxpstats<74>ncols<6C>
input_whis<EFBFBD>iir<69>r<><00>statsr<73>r<>r<><00>loval<61>hival<61>wiskhi<68>wisklor<6F>s @r<00> boxplot_statsr<73>Ms8<00><><00>^
<12> $<24> <12>H<EFBFBD> <14>A<EFBFBD>s<EFBFBD><1B>A<EFBFBD> <0F><01>F<EFBFBD>E<EFBFBD> <0A>~<7E><1A>!<21>!<21>$<24>'<27><06> <0C>V<EFBFBD><1B><05> <1D><18>H<>I<>I<><15>J<EFBFBD>#<23>C<EFBFBD><01>6<EFBFBD>N<EFBFBD>3<>M=<3D><0E><02>J<EFBFBD>Q<EFBFBD><05><13><05> <10> <1C>"<22>E<EFBFBD>'<27>N<EFBFBD><1A><04> <11><0F><0F><05><1E> <0F>q<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B> <20>h<EFBFBD>h<EFBFBD>r<EFBFBD>l<EFBFBD>E<EFBFBD>(<28>O<EFBFBD><1E>F<EFBFBD>F<EFBFBD>E<EFBFBD>&<26>M<EFBFBD><1D>6<EFBFBD>6<EFBFBD>E<EFBFBD>%<25>L<EFBFBD><1C>&<26>&<26>E<EFBFBD>$<24>K<EFBFBD><1C>&<26>&<26>E<EFBFBD>$<24>K<EFBFBD><1D>6<EFBFBD>6<EFBFBD>E<EFBFBD>%<25>L<EFBFBD><1E>F<EFBFBD>F<EFBFBD>E<EFBFBD>&<26>M<EFBFBD><1E>F<EFBFBD>F<EFBFBD>E<EFBFBD>&<26>M<EFBFBD> <20>f<EFBFBD>f<EFBFBD>E<EFBFBD>(<28>O<EFBFBD> <20>f<EFBFBD>f<EFBFBD>E<EFBFBD>(<28>O<EFBFBD> <14> <0F>E<EFBFBD>E<EFBFBD>M<EFBFBD>M<EFBFBD>!<21> <1C><01> <0A>F<EFBFBD>F<EFBFBD>A<EFBFBD>F<EFBFBD>F<EFBFBD>7<EFBFBD>O<EFBFBD> !<21> !<21> #<23><01><1B><07><07><01>
<EFBFBD><05>f<EFBFBD> <0A><19>m<EFBFBD>m<EFBFBD>A<EFBFBD>|<7C>4<> <0B><02>C<EFBFBD><12><1A>B<EFBFBD>w<EFBFBD><05>e<EFBFBD> <0C> <10><15><<3C>1<EFBFBD> <1C><19><1B>D<EFBFBD>(><3E> <0A>s<EFBFBD>E<EFBFBD>%<25>L<EFBFBD>)<29>(
<EFBFBD>$<24><05>f<EFBFBD> <0A>u<EFBFBD>V<EFBFBD>}<7D>
<0E>;<3B>;<3B>t<EFBFBD> <1C>Z<EFBFBD><04>c<EFBFBD>%:<3A><1D>=<3D>=<3D><11>D<EFBFBD>1<>L<EFBFBD>E<EFBFBD>5<EFBFBD> <0F>Y<EFBFBD>Y<EFBFBD>t<EFBFBD>_<EFBFBD><16><14><05>e<EFBFBD> <0C>,<2C>,<2C>E<EFBFBD><16><14><05>e<EFBFBD> <0C>,<2C>,<2C>E<EFBFBD><1C>J<>K<> K<><13>1<EFBFBD><05>:<3A><1D><06> <0E>v<EFBFBD>;<3B>!<21> <1B>r<EFBFBD>v<EFBFBD>v<EFBFBD>f<EFBFBD>~<7E><02>2<> <20>E<EFBFBD>(<28>O<EFBFBD> <20>f<EFBFBD>f<EFBFBD>V<EFBFBD>n<EFBFBD>E<EFBFBD>(<28>O<EFBFBD><13>1<EFBFBD><05>:<3A><1D><06> <0E>v<EFBFBD>;<3B>!<21> <1B>r<EFBFBD>v<EFBFBD>v<EFBFBD>f<EFBFBD>~<7E><02>2<> <20>E<EFBFBD>(<28>O<EFBFBD> <20>f<EFBFBD>f<EFBFBD>V<EFBFBD>n<EFBFBD>E<EFBFBD>(<28>O<EFBFBD><1D>.<2E>.<2E> <0A>a<EFBFBD>%<25><08>/<2F>!<21> "<22> <0A>a<EFBFBD>%<25><08>/<2F>!<21> "<22>*
<EFBFBD> <0B><05>h<EFBFBD><0F> 24<32>S<EFBFBD>"<22>.<2E><05>d<EFBFBD> <0B>U<EFBFBD>5<EFBFBD>\<5C>5<EFBFBD><14>;<3B>[M=<3D>^ <14>Or<00>solid<69>dashed<65>dashdot<6F>dotted)<04>-z--z-.<2E>:c <00>T<00>tj|t<00><01>}|jsgStj|dd|ddk7<00>\}|dz }|j <00>}|drdg|z}|dr|j t|<00><00>tt|ddd<06>|ddd<06><00><00>S)zv
Return a list of (ind0, ind1) such that ``mask[ind0:ind1].all()`` is
True and we cover all such regions.
r<>Nr<4E>r<>rr<>)
rr<><00>boolr<6C>r<><00>tolistrjr<>r|r<>)r<><00>idxs r<00>contiguous_regionsrs<><00><00>
<0E>:<3A>:<3A>d<EFBFBD>$<24> '<27>D<EFBFBD> <0F>9<EFBFBD>9<EFBFBD><11> <09> <0E>:<3A>:<3A>d<EFBFBD>3<EFBFBD>B<EFBFBD>i<EFBFBD>4<EFBFBD><01><02>8<EFBFBD>+<2B> ,<2C>D<EFBFBD>C<EFBFBD><07>1<EFBFBD>H<EFBFBD>C<EFBFBD> <0E>*<2A>*<2A>,<2C>C<EFBFBD> <0C>A<EFBFBD>w<EFBFBD><10>c<EFBFBD>C<EFBFBD>i<EFBFBD><03> <0B>B<EFBFBD>x<EFBFBD> <0B>
<EFBFBD>
<EFBFBD>3<EFBFBD>t<EFBFBD>9<EFBFBD><1D> <0F><03>C<EFBFBD><03>!<21><03>H<EFBFBD>c<EFBFBD>!<21>$<24>Q<EFBFBD>$<24>i<EFBFBD>(<28> )<29>)rc<00><><00>t|<00>}|jd<01>|jd<02>z
}|dkDxr|dzdk(}|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.
r<>z\$rr<>)r<>r<>)r<><00> dollar_count<6E> even_dollarss r<00> is_math_textr6sF<00><00> <0C>A<EFBFBD><06>A<EFBFBD><14>7<EFBFBD>7<EFBFBD>4<EFBFBD>=<3D>1<EFBFBD>7<EFBFBD>7<EFBFBD>5<EFBFBD>><3E>1<>L<EFBFBD> <20>1<EFBFBD>$<24>><3E><1C><01>)9<>Q<EFBFBD>)><3E>L<EFBFBD> <17>rc<00><><00>t|d<01>rAtjj|t<00>j tj <00>Stj|t<00>S)zt
Convert a sequence to a float array; if input was a masked array, masked
values are converted to nans.
r<>)r<>rr<r<>r<>r<>r<>r<>s r<00>_to_unmasked_float_arrayrCsC<00><00>
<0F>q<EFBFBD>&<26><19><11>u<EFBFBD>u<EFBFBD>}<7D>}<7D>Q<EFBFBD><05>&<26>-<2D>-<2D>b<EFBFBD>f<EFBFBD>f<EFBFBD>5<>5<><11>z<EFBFBD>z<EFBFBD>!<21>U<EFBFBD>#<23>#rc<00><><00>t|<00>}t|d<01>r$t|d<02>rt|j<00>dkrt j
|<00>S|S)z8Convert scalars to 1D arrays; pass-through arrays as is.r<>r<>r<>)<06>_unpack_to_numpyr<79>r<>r<>r<00>
atleast_1dr<EFBFBD>s r<00> _check_1dr NsH<00><00> <19><11><1B>A<EFBFBD> <14>A<EFBFBD>w<EFBFBD> <1F><17><01>6<EFBFBD>"<22> <0F><01><07><07>L<EFBFBD>1<EFBFBD> <1C><11>}<7D>}<7D>Q<EFBFBD><1F><1F><10>rc<00><><00>t|<00>}t|tj<00>r<>|j <00>}t |<00>dk(rggS|j dk(rtj |d<00>dk(r|gS|j dvr$|D<00>cgc]}tj|d<04><00><02>c}St|<01>d<05><02><00>t |<00>dk(rggSg}d}|D]}}t|t<00>s t|<05>d}tj|<05>}tj |<05>}|dkDrt|<01>d<05><02><00>|j|jd<04><00><00>|rtj|d<04>gS|Scc}w#t$rY<00><>wxYw)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<>)r<>r<>r<>z must have 2 or fewer dimensionsTF)r rRrr<><00> transposer<65>r<>r<>r<>r<>r<>r[r<>rj)r<><00>namer<65><00>result<6C>is_1d<31>xi<78>nds rr<>r<>]si<00><00> <19><11><1B>A<EFBFBD><12>!<21>R<EFBFBD>Z<EFBFBD>Z<EFBFBD> <20> <0A>K<EFBFBD>K<EFBFBD>M<EFBFBD><01> <0E>q<EFBFBD>6<EFBFBD>Q<EFBFBD>;<3B><16>4<EFBFBD>K<EFBFBD> <0E>V<EFBFBD>V<EFBFBD>q<EFBFBD>[<5B>R<EFBFBD>W<EFBFBD>W<EFBFBD>Q<EFBFBD>q<EFBFBD>T<EFBFBD>]<5D>a<EFBFBD>/<2F><15>3<EFBFBD>J<EFBFBD> <0E>V<EFBFBD>V<EFBFBD>v<EFBFBD> <1D>/0<>1<>!<21>B<EFBFBD>J<EFBFBD>J<EFBFBD>q<EFBFBD>"<22>%<25>1<> 1<><1C><04>v<EFBFBD>%E<>F<>G<> G<> <0B>1<EFBFBD>v<EFBFBD><11>{<7B><12>t<EFBFBD> <0B> <0F>F<EFBFBD> <10>E<EFBFBD><0F>&<26><02><1A>"<22>c<EFBFBD>"<22> <1E><14>R<EFBFBD><08><1E><05> <0F>]<5D>]<5D>2<EFBFBD> <1E><02> <0F>W<EFBFBD>W<EFBFBD>R<EFBFBD>[<5B><02> <0A><01>6<EFBFBD><1C><04>v<EFBFBD>%E<>F<>G<> G<><0E> <0A> <0A>b<EFBFBD>j<EFBFBD>j<EFBFBD><12>n<EFBFBD>%<25>&<26>  <0A><12>
<EFBFBD>
<EFBFBD>6<EFBFBD>2<EFBFBD>&<26>'<27>'<27><16> <0A><>?2<><32> <1D> <15><14> <15>s<00>E&<04> E+<02>+ E7<05>6E7c<00><><00>g}t|d<01>}|<03>t|<03>dk7r t|d<03>}nggt|<00>z}t|<00>t|<03>k7r td<04><00>t||<03>D]<5D>\}}i}t j
|<05>}t j |<05>} t j|d|z<00>}
t j|| |<02>} ||| <0B>|d<| |d<t j|<05>|d<t j|<05>|d <||d
<| |d <t j|
<EFBFBD>|d<|j|<07><00><>|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.
r<>r<00> quantileszLList of violinplot statistics and quantiles values must have the same lengthr<68><00>vals<6C>coordsr<73>r<>r'r*) r<>r<>r<>r<>rr'r*r<><00>linspacer<65>r<>r
rj) r<><00>method<6F>pointsr<00>vpstatsr<73><00>qr<71><00>min_val<61>max_val<61> quantile_valrs r<00> violin_statsr<00>sH<00><00>j<11>G<EFBFBD> <14>A<EFBFBD>s<EFBFBD><1B>A<EFBFBD><11><1C><13>Y<EFBFBD><1E>1<EFBFBD>!4<><1F> <09>;<3B>7<> <09><18>D<EFBFBD>3<EFBFBD>q<EFBFBD>6<EFBFBD>M<EFBFBD> <09> <0B>1<EFBFBD>v<EFBFBD><13>Y<EFBFBD><1E><1F><18>6<>7<> 7<><16>a<EFBFBD><19>#<23><1E><06><11>A<EFBFBD><12><05><15>&<26>&<26><11>)<29><07><14>&<26>&<26><11>)<29><07><19>}<7D>}<7D>Q<EFBFBD><03>a<EFBFBD><07>0<> <0C><14><1B><1B>W<EFBFBD>g<EFBFBD>v<EFBFBD>6<><06><1E>q<EFBFBD>&<26>)<29><05>f<EFBFBD> <0A> <20><05>h<EFBFBD><0F><1B><07><07><01>
<EFBFBD><05>f<EFBFBD> <0A><1C>)<29>)<29>A<EFBFBD>,<2C><05>h<EFBFBD><0F><1E><05>e<EFBFBD> <0C><1E><05>e<EFBFBD> <0C><1F>]<5D>]<5D><<3C>8<><05>k<EFBFBD><1A> <10><0E><0E>u<EFBFBD><1D>-<1E>0 <13>Nrc <00><><00>tjdt|<01>ztdt|<00>zdz
d<03>f<02>}||dddd<02>f<|dddd<02>f|dddd<02>f<||dd<04>ddd<02>f<|dd<04>ddd<02>f|dd<04>ddd<02>f<|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)
r<>r<>rN<><4E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>r<00>zerosr<73>r*<00>r<>rr<>s r<00>pts_to_prestepr%<00>s<><00><00>8 <0F>H<EFBFBD>H<EFBFBD>a<EFBFBD>#<23>d<EFBFBD>)<29>m<EFBFBD>S<EFBFBD><11>S<EFBFBD><11>V<EFBFBD><1A>a<EFBFBD><1E><11>%;<3B><<3C> =<3D>E<EFBFBD><17>E<EFBFBD>!<21>Q<EFBFBD>T<EFBFBD><01>T<EFBFBD>'<27>N<EFBFBD><1A>1<EFBFBD>a<EFBFBD><02>1<EFBFBD>f<EFBFBD>9<EFBFBD>%<25>E<EFBFBD>!<21>Q<EFBFBD>T<EFBFBD><01>T<EFBFBD>'<27>N<EFBFBD><1A>E<EFBFBD>!<21>"<22>a<EFBFBD>d<EFBFBD><11>d<EFBFBD>(<28>O<EFBFBD><1B>A<EFBFBD>B<EFBFBD><01><04>1<EFBFBD><04>H<EFBFBD>o<EFBFBD>E<EFBFBD>!<21>"<22>a<EFBFBD>d<EFBFBD><11>d<EFBFBD>(<28>O<EFBFBD> <10>Lrc <00><><00>tjdt|<01>ztdt|<00>zdz
d<03>f<02>}||dddd<02>f<|dddd<02>f|dddd<02>f<||dd<04>ddd<02>f<|dd<04>ddd<02>f|dd<04>ddd<02>f<|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)
r<>r<>rNr!r"r$s r<00>pts_to_poststepr'!s<><00><00>8 <0F>H<EFBFBD>H<EFBFBD>a<EFBFBD>#<23>d<EFBFBD>)<29>m<EFBFBD>S<EFBFBD><11>S<EFBFBD><11>V<EFBFBD><1A>a<EFBFBD><1E><11>%;<3B><<3C> =<3D>E<EFBFBD><16>E<EFBFBD>!<21>Q<EFBFBD>T<EFBFBD><01>T<EFBFBD>'<27>N<EFBFBD><1A>1<EFBFBD>a<EFBFBD>d<EFBFBD><11>d<EFBFBD>7<EFBFBD>^<5E>E<EFBFBD>!<21>Q<EFBFBD>T<EFBFBD><01>T<EFBFBD>'<27>N<EFBFBD><1A>E<EFBFBD>!<21>"<22>a<EFBFBD>d<EFBFBD><11>d<EFBFBD>(<28>O<EFBFBD><1B>A<EFBFBD>B<EFBFBD><01>"<22>Q<EFBFBD><06>J<EFBFBD>'<27>E<EFBFBD>!<21>"<22>a<EFBFBD>d<EFBFBD><11>d<EFBFBD>(<28>O<EFBFBD> <10>Lrc<00>B<00>tjdt|<01>zdt|<00>zf<02>}tj|<00>}|dd|ddzdz x|dddd<02>f<|dddd<02>f<|dd|ddd<01>f<|dd|ddd<03>f<||dd<03>ddd<02>f<|dd<03>ddd<02>f|dd<03>ddd<02>f<|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)
r<>r<>Nr<4E>r)rr#r<>r<>r$s r<00>pts_to_midstepr)Es<><00><00>8 <0F>H<EFBFBD>H<EFBFBD>a<EFBFBD>#<23>d<EFBFBD>)<29>m<EFBFBD>Q<EFBFBD><13>Q<EFBFBD><16>Z<EFBFBD>0<> 1<>E<EFBFBD>
<EFBFBD> <0A> <0A>a<EFBFBD><18>A<EFBFBD>)*<2A>3<EFBFBD>B<EFBFBD><16>!<21>A<EFBFBD>B<EFBFBD>%<25><1E>1<EFBFBD>(<<3C><<3C>E<EFBFBD>!<21>Q<EFBFBD>r<EFBFBD>!<21>V<EFBFBD>)<29><14>u<EFBFBD>Q<EFBFBD><01><04>1<EFBFBD><04>W<EFBFBD>~<7E><14>R<EFBFBD>a<EFBFBD>5<EFBFBD>E<EFBFBD>!<21>R<EFBFBD>a<EFBFBD>R<EFBFBD>%<25>L<EFBFBD><15>b<EFBFBD>c<EFBFBD>F<EFBFBD>E<EFBFBD>!<21>R<EFBFBD>S<EFBFBD>&<26>M<EFBFBD><1A>E<EFBFBD>!<21>"<22>a<EFBFBD>d<EFBFBD><11>d<EFBFBD>(<28>O<EFBFBD><1B>A<EFBFBD>B<EFBFBD><01><04>1<EFBFBD><04>H<EFBFBD>o<EFBFBD>E<EFBFBD>!<21>"<22>a<EFBFBD>d<EFBFBD><11>d<EFBFBD>(<28>O<EFBFBD> <10>Lrc<00>
<00>||fSr
r )r<><00>ys r<00><lambda>r,ks
<00><00>A<EFBFBD>q<EFBFBD>6<EFBFBD>r)<05>defaultr<74>z steps-prez
steps-postz steps-midc<00> <00> |jj<00>|j<00>fS#t$rYnwxYw t|<00>}t j
|j dt<00><02>|fS#ttf$r Ytd<03><00>wxYw)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.
rr<>z5Input could not be cast to an at-least-1D NumPy array)
rG<00>to_numpy<70>AttributeErrorr rr<>r<>r<>rr<>)r+s r<00>index_ofr1rs<><00><00>* <0A><10>w<EFBFBD>w<EFBFBD><1F><1F>!<21>1<EFBFBD>:<3A>:<3A><<3C>/<2F>/<2F><> <19> <0A> <0C> <0A><>5<> <15>a<EFBFBD>L<EFBFBD><01>
<12>y<EFBFBD>y<EFBFBD><11><17><17><11><1A>5<EFBFBD>1<>1<EFBFBD>4<>4<><34> &<26>z<EFBFBD> 2<> <0A> <0C> <15>L<>
M<EFBFBD>M<>  <0A>s<00>),<00> 8<03>8<03> A1<00>1B <03> B c<00><><00>t|tjj<00>r |dSt t|<00><00>S#t$r Yt d<02><00>wxYw)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<00>/matplotlib does not support generators as input)rR<00> collections<6E>abc<62>Iteratorr[<00> RuntimeErrorr<72>r<>r<>s r<00>safe_first_elementr8<00>sV<00><00><12>#<23>{<7B><EFBFBD><EFBFBD>/<2F>/<2F>0<>
 <11><16>q<EFBFBD>6<EFBFBD>M<EFBFBD> <10><04>S<EFBFBD> <09>?<3F><1A><><19> <11> <10><1A>L<>M<>M<> <11>s<00>?<00> A<03>Ac<00><><00>d<01>}t|tj<00>r|dSt|tjj
<00>r t d<03><00>|D]}||<02>s<01> |cSt|<00>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<00><><00>|<00>y tj|<00>S#ttf$rYnwxYw t j
|<00>rt j|<00>SdS#t$rYywxYw)NFT)<06>mathr>r[r<>r<00>isscalarrs r<00> safe_isfinitez)_safe_first_finite.<locals>.safe_isfinite<74>so<00><00> <0E>;<3B><18> <11><17>=<3D>=<3D><13>%<25> %<25><><19>:<3A>&<26> <11> <11>  <11><>
 <18>')<29>{<7B>{<7B>3<EFBFBD>'7<>2<EFBFBD>;<3B>;<3B>s<EFBFBD>#<23> A<>T<EFBFBD> A<><41><18> <18><18> <18>s#<00><00>,<03>,<03>)A<00>A<00> A(<03>'A(rr3)rRr<00>flatiterr4r5r6r7r8)rNr=rs r<00>_safe_first_finiter?<00>si<00><00><18>"<12>#<23>r<EFBFBD>{<7B>{<7B>#<23><12>1<EFBFBD>v<EFBFBD> <0A> <13>C<EFBFBD><1B><1F><1F>1<>1<> 2<><1A>L<>M<>M<><16> <1B>C<EFBFBD><1C>S<EFBFBD>!<21><1A>
<EFBFBD> <1B>"<22>#<23>&<26>&rc<00>d<00>t|tjj<00>r t |<00>S|S)zP
Convert dictview objects to list. Other inputs are returned unchanged.
)rRr4r5<00> MappingViewr|)r<>s r<00>sanitize_sequencerB<00>s+<00><00>%<25>T<EFBFBD>;<3B>?<3F>?<3F>+F<>+F<>G<>D<EFBFBD><14>J<EFBFBD><17><15>rc<00><><00>ddlm}|<00>iS|<01>i}n5t|t<00>r t ||<02>s t||<02>r t |di<00>}|j <00>D<00><03><04>cic]\}}|D]}||<03><03><00>}}}}i}i}|j <00>D]:\} }
|j| | <09>}||vrtd||<00>d| <09>d<06><05><00>| ||<|
||<<00><|Scc}}}w)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)<01>Artist<73>
_alias_mapz Got both z and z", which are aliases of one another) <09>matplotlib.artistrDrRr<00>
issubclassr<EFBFBD>r<>r/r[) <0B>kw<6B> alias_mappingrD<00> canonical<61>
alias_list<EFBFBD>alias<61> to_canonical<61>canonical_to_seen<65>retrfrgs r<00>normalize_kwargsrP<00>s<00><00>6)<29> <09>z<EFBFBD><11> <09><15><1C><1A> <0A>
<14>]<5D>D<EFBFBD>
)<29>j<EFBFBD><1D><06>.O<> <17> <0A>v<EFBFBD> .<2E><1F> <0A>|<7C>R<EFBFBD>@<40> <0A>2?<3F>1D<31>1D<31>1F<31>-<2D>-<2D>-<2D> <09>:<3A>!+<2B>-<2D><1D><1A>9<EFBFBD>$<24>-<2D>E<EFBFBD>-<2D>L<EFBFBD>-<2D><1B><15>
<0C>C<EFBFBD><12><08><08>
<EFBFBD><1B><04><01>1<EFBFBD> <20>$<24>$<24>Q<EFBFBD><01>*<2A> <09> <14>)<29> )<29><1B>i<EFBFBD>(9<>)<29>(D<>'G<>u<EFBFBD> <20>e<EFBFBD>#E<>G<01>H<01> H<01>'(<28><19>)<29>$<24><1A><03>I<EFBFBD><0E> <1B> <0F>J<EFBFBD><4A>-s<00>Cc#<00><>K<00>t|<00>}|j|jdz<00>}d}d}t|<02>D]} |j d<04>5 ddd<05>ntdj|<01><00><00> d<05><02>|j<00>y#1swYnxYw<01>_#t
$rt j|<03>Y<00>wxYw#|j<00>wxYw<01>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-lockr<6B>g<><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?<3F>xbNz<4E>Lock 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<00> with_namer<00>ranger<65><00>FileExistsError<6F>time<6D>sleep<65> TimeoutError<6F>format<61>unlink)r<00> lock_path<74>retries<65> sleeptime<6D>_s r<00>
_lock_pathr_s<><00><00><><00> <10><04>:<3A>D<EFBFBD><14><0E><0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>+=<3D>=<3D>><3E>I<EFBFBD><10>G<EFBFBD><13>I<EFBFBD> <12>7<EFBFBD>^<5E> <18><01> "<22><1A><1E><1E><04>%<25> <16><15> <16> <16> <18><1B>H<01>IO<01><06> <15>I<17> <18> <18> <1B> <0A><11><18><18><1A> <16> <16><> <16><><1E> "<22> <10>J<EFBFBD>J<EFBFBD>y<EFBFBD> !<21> "<22><> <12><18><18><1A>s^<00><C<01>B<02>B <05>B<02>C<01>8B><00><C<01> B <09>B<02>C<01>B;<05>8C<01>:B;<05>;C<01>>C<03>C<01>zorderr{c<00>$<00>|t|<00><00>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.
)<01>reversed)<02>artists<74> _cached_maxs r<00>_topmost_artistre7s<00><00> <17>x<EFBFBD><07>(<28> )<29>)rc<00>0<00>t|t<00>xr||k(S)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.
)rRr<><00>rNr<>s r<00>
_str_equalrhDs<00><00> <16>c<EFBFBD>3<EFBFBD> <1F> ,<2C>C<EFBFBD>1<EFBFBD>H<EFBFBD>,rc<00>L<00>t|t<00>xr|j<00>|k(S)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.
)rRr<>r rgs r<00>_str_lower_equalrjOs!<00><00> <16>c<EFBFBD>3<EFBFBD> <1F> 4<>C<EFBFBD>I<EFBFBD>I<EFBFBD>K<EFBFBD>1<EFBFBD>$4<>4rc<00><><00>tjdd}tjddd<02>}tj|d|f||df|d|f||dff<04>S)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<>)r<00>s_r<5F>)<03>arrr(<00>backwards r<00>_array_perimeterroZsk<00><00>:<11>e<EFBFBD>e<EFBFBD>A<EFBFBD>b<EFBFBD>k<EFBFBD>G<EFBFBD><11>u<EFBFBD>u<EFBFBD>R<EFBFBD><01>"<22>W<EFBFBD>~<7E>H<EFBFBD> <0A>><3E>><3E> <0B>A<EFBFBD>w<EFBFBD>J<EFBFBD><0F> <0B>G<EFBFBD>R<EFBFBD>K<EFBFBD><18> <0B>B<EFBFBD><08>L<EFBFBD><19> <0B>H<EFBFBD>a<EFBFBD>K<EFBFBD><18> <06> <07>rc<00><><00>g|j<00>|<02>}g|j<00>|j|<00>}|||z
|zdz||<|||z||<tjjj |||d<02><03>S)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]]])
r<>F)r<><00>strides<65> writeable)r<>rqr<00>lib<69> stride_tricks<6B>
as_strided)rmr<>r<>rJ<00> new_shape<70> new_stridess r<00>_unfoldrx<00>s<><00><00>P#<23>#<23>)<29>)<29>"<22>T<EFBFBD>"<22>I<EFBFBD>3<>C<EFBFBD>K<EFBFBD>K<EFBFBD>3<><13><1B><1B>T<EFBFBD>!2<>3<>K<EFBFBD> <20><14><EFBFBD><14>-<2D>$<24>6<><11>:<3A>I<EFBFBD>d<EFBFBD>O<EFBFBD>#<23>D<EFBFBD>)<29>D<EFBFBD>0<>K<EFBFBD><04><15> <0A>6<EFBFBD>6<EFBFBD> <1F> <1F> *<2A> *<2A>3<EFBFBD>1:<3A>3><3E>5:<3A> +<2B> <<3C><rc<00><><00>|dkDr|dkDsJ<00>|jddz
|zdk(sJ<00>|jddz
|zdk(sJ<00>t|dd|<01>dd<04>fd||<02>}t||d|<01>dd<03>fd||<02>dddd<04>f}t|dd<04>|d|<02>fd||<01>}t|dd<03>dd|<02>fd||<01>dddd<04>f}tj||||fd<06><07>j dd||zz<00>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))
rr<>Nr<4E>.r<><00>r<>)r<>rxrr<>r<>)r<><00>rstride<64>cstride<64>top<6F>bottom<6F>right<68>lefts r<00>_array_patch_perimetersr<73><00>s2<00><00>* <13>Q<EFBFBD>;<3B>7<EFBFBD>Q<EFBFBD>;<3B>&<26> &<26> <0A>G<EFBFBD>G<EFBFBD>A<EFBFBD>J<EFBFBD><11>N<EFBFBD>g<EFBFBD> %<25><11> *<2A>*<2A> *<2A> <0A>G<EFBFBD>G<EFBFBD>A<EFBFBD>J<EFBFBD><11>N<EFBFBD>g<EFBFBD> %<25><11> *<2A>*<2A> *<2A>$ <12>!<21>K<EFBFBD>R<EFBFBD><07>K<EFBFBD><13>"<22><13>$<24>%<25>q<EFBFBD>'<27>7<EFBFBD>
;<3B>C<EFBFBD> <14>Q<EFBFBD>w<EFBFBD>'<27><07>'<27><11><12>+<2B>,<2C>a<EFBFBD><17>'<27> B<>3<EFBFBD><04>"<22><04>9<EFBFBD> M<>F<EFBFBD> <13>A<EFBFBD>c<EFBFBD>r<EFBFBD>c<EFBFBD>7<EFBFBD>+<2B>G<EFBFBD>+<2B>+<2B>,<2C>a<EFBFBD><17>'<27> B<>E<EFBFBD> <12>1<EFBFBD>Q<EFBFBD>R<EFBFBD><1B>"<22>W<EFBFBD><1B>_<EFBFBD>%<25>q<EFBFBD>'<27>7<EFBFBD> ;<3B>C<EFBFBD><14>2<EFBFBD><14>I<EFBFBD> F<>D<EFBFBD> <0E>N<EFBFBD>N<EFBFBD>C<EFBFBD><15><06><04>5<>A<EFBFBD> ><3E><16>w<EFBFBD>r<EFBFBD>1<EFBFBD><07>'<27> 1<>2<>3<>5rc+<00>K<00>t<00>}i}|D]W}t|||<02>}||jvs||ur|||<<00>(tt|<00>|<04>}t |t
<00>r|||<<00>S|||<<00>Y |j <00>D]\}}t|||<07><00>d<01><02>|j <00>D]#\}}||ur t||<04><00>t|||<05><00>%y#|j <00>D]#\}}||ur t||<04><00>t|||<05><00>%wxYw<01>w)zR
Temporarily set some attributes; restore original state at context exit.
N) rsr<><00>__dict__rrR<00>propertyr<79><00>setattr<74>delattr)rNr<><00>sentinel<65>origs<67>attrr<72><00>cls_origrs r<00> _setattr_cmr<6D><00>s<00><00><><00>
<16>x<EFBFBD>H<EFBFBD> <0E>E<EFBFBD><16>'<27><04><16>s<EFBFBD>D<EFBFBD>(<28>+<2B><04> <0F>3<EFBFBD><<3C><<3C> <1F>4<EFBFBD>8<EFBFBD>#3<><1F>E<EFBFBD>$<24>K<EFBFBD><1F>t<EFBFBD>C<EFBFBD>y<EFBFBD>$<24>/<2F>H<EFBFBD><1A>(<28>H<EFBFBD>-<2D>"<22><05>d<EFBFBD> <0B>'<27><05>d<EFBFBD> <0B>/'<27>2 )<29><1F><1C><1C><1E> $<24>I<EFBFBD>D<EFBFBD>#<23> <13>C<EFBFBD><14>s<EFBFBD> #<23> $<24> <0A><1F>+<2B>+<2B>-<2D> )<29>J<EFBFBD>D<EFBFBD>$<24><13>x<EFBFBD><1F><17><03>T<EFBFBD>"<22><17><03>T<EFBFBD>4<EFBFBD>(<28>  )<29><>%<25>+<2B>+<2B>-<2D> )<29>J<EFBFBD>D<EFBFBD>$<24><13>x<EFBFBD><1F><17><03>T<EFBFBD>"<22><17><03>T<EFBFBD>4<EFBFBD>(<28>  )<29>s<00>A)D<01>,)C <00>7D<01> 8D<03>Dc<00>0<00>eZdZd<01>Zd<02>Zd<03>Zd<04>Zd<05>Zd<06>Zy)<08> _OrderedSetc<00>6<00>tj<00>|_yr
)r4<00> OrderedDict<63>_odrs rrz_OrderedSet.__init__s<00><00><1E>*<2A>*<2A>,<2C><04>rc<00><00>||jvSr
)r<><00>rrks rriz_OrderedSet.__contains__s<00><00><12>d<EFBFBD>h<EFBFBD>h<EFBFBD><EFBFBD>rc<00>,<00>t|j<00>Sr
)r<>r<>rs rrwz_OrderedSet.__iter__s<00><00><13>D<EFBFBD>H<EFBFBD>H<EFBFBD>~<7E>rc<00>,<00>t|j<00>Sr
)r<>r<>rs rr#z_OrderedSet.__len__s<00><00><12>4<EFBFBD>8<EFBFBD>8<EFBFBD>}<7D>rc<00>Z<00>|jj|d<00>d|j|<yr
<00>r<>rtr<>s rr<>z_OrderedSet.adds!<00><00> <0C><08><08> <0C> <0C>S<EFBFBD>$<24><1F><1C><04><08><08><13> rc<00><<00>|jj|d<00>yr
r<>r<>s rr<>z_OrderedSet.discard!s<00><00> <0C><08><08> <0C> <0C>S<EFBFBD>$<24>rN) rrrrrirwr#r<>r<>r rrr<>r<>s <00><00>-<2D><1F><1E><1D><1D> rr<>c<00><00>tj|tjdk(rgd<02>ngd<03>d<04><05>}|ddd<08>f}|d }|d
k7}tj|d<08>D]/}||j t <00>d z||dzz||z||<<00>1|S) zS
Convert a premultiplied ARGB32 buffer to an unmultiplied RGBA8888 buffer.
<20>little<6C>r<>r<>rr&)r<>r<>r&rr<>rz.Nr<4E>).r<>r<00><>)r<00>taker-<00> byteorder<65>rollaxis<69>astype<70>int)<06>buf<75>rgba<62>rgb<67>alphar<61><00>channels r<00>._premultiplied_argb32_to_unmultiplied_rgba8888r<38>)s<><00><00> <0E>7<EFBFBD>7<EFBFBD> <0B><1B> <0A> <0A><18>1<> <0C>|<7C>!<21> M<01>D<EFBFBD> <0F>s<EFBFBD>C<EFBFBD>R<EFBFBD>C<EFBFBD>x<EFBFBD>.<2E>C<EFBFBD> <10><17>M<EFBFBD>E<EFBFBD> <10>A<EFBFBD>:<3A>D<EFBFBD><15>;<3B>;<3B>s<EFBFBD>B<EFBFBD>'<27><1C><07> <14>T<EFBFBD>]<5D> !<21> !<21>#<23> &<26><13> ,<2C>u<EFBFBD>T<EFBFBD>{<7B>a<EFBFBD>/?<3F> ?<3F><14>T<EFBFBD>{<7B> <1B> <10><04> <0A><1C> <10>Krc<00><<00>tjdk(r-tj|gd<02>d<03><04>}|ddd<07>f}|ddd<06>f}n,tj|gd<08>d<03><04>}|ddd <09>f}|dd d<06>f}|j <00>d
k7rtj
||d
z |d <0B> <0C>|S) zS
Convert an unmultiplied RGBA8888 buffer to a premultiplied ARGB32 buffer.
r<>r<>r<>rz.Nr<4E>)r&rr<>r<>r<>r<><00>unsafe)r<><00>casting)r-r<>rr<>r'<00>multiply)<04>rgba8888<38>argb32<33>rgb24<32>alpha8s r<00>._unmultiplied_rgba8888_to_premultiplied_argb32r<32>;s<><00><00> <0B>}<7D>}<7D><08> <20><13><17><17><18><<3C>a<EFBFBD>8<><06><16>s<EFBFBD>C<EFBFBD>R<EFBFBD>C<EFBFBD>x<EFBFBD> <20><05><17><03>R<EFBFBD>S<EFBFBD><08>!<21><06><13><17><17><18><<3C>a<EFBFBD>8<><06><17><03>R<EFBFBD>a<EFBFBD>R<EFBFBD><07><1F><06><16>s<EFBFBD>A<EFBFBD>B<EFBFBD>w<EFBFBD><0F><05><0E>z<EFBFBD>z<EFBFBD>|<7C>t<EFBFBD><1B>
<EFBFBD> <0B> <0B>E<EFBFBD>6<EFBFBD>D<EFBFBD>=<3D>e<EFBFBD>X<EFBFBD>F<> <11>Mrc<00>J<00>|jd<01><02>j<00>\}|jd<03><02>j<00>\}t|<01>r=t|<02>r2|ddg\}}|ddg\}}t||dz<00>t||dz<00>fStdd<01>tdd<01>fS)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.
rrzr<>r<>)<04>anyr<79>r<><00>slice)r<><00>x_nz<6E>y_nz<6E>lr ru<00>ts r<00>_get_nonzero_slicesr<73>Os<><00><00> <10>G<EFBFBD>G<EFBFBD><11>G<EFBFBD>O<EFBFBD> #<23> #<23> %<25>E<EFBFBD>D<EFBFBD> <0F>G<EFBFBD>G<EFBFBD><11>G<EFBFBD>O<EFBFBD> #<23> #<23> %<25>E<EFBFBD>D<EFBFBD>
<EFBFBD>4<EFBFBD>y<EFBFBD>S<EFBFBD><14>Y<EFBFBD><13>Q<EFBFBD><02>G<EFBFBD>}<7D><04><01>1<EFBFBD><13>Q<EFBFBD><02>G<EFBFBD>}<7D><04><01>1<EFBFBD><14>Q<EFBFBD><01>A<EFBFBD><05><EFBFBD><05>a<EFBFBD><11>Q<EFBFBD><15><0F>/<2F>/<2F><14>Q<EFBFBD><01>{<7B>E<EFBFBD>!<21>Q<EFBFBD>K<EFBFBD>'<27>'rc<00>V<00>t|t<00>r|Sdjd<02>|D<00><00>S)zAPretty-format a subprocess command for printing/logging purposes.r<>c3<00>lK<00>|],}tjtj|<01><00><00><01><00>.y<00>wr
)<04>shlex<65>quoter<65>r<>)r<>rns rr<>z&_pformat_subprocess.<locals>.<genexpr>ds!<00><00><><00>I<>#<23>%<25>+<2B>+<2B>b<EFBFBD>i<EFBFBD>i<EFBFBD><03>n<EFBFBD>5<>I<>s<00>24)rRr<>rq)<01>commands r<00>_pformat_subprocessr<73>as,<00><00>!<21>'<27>3<EFBFBD>/<2F>G<EFBFBD>K<01><14><18><18>I<><17>I<>I<>Krc <00>"<00>|jdt|<00><00>tj|fddi|<02><01>}|jru|j
}t |t<00>r|j<00>}|j}t |t<00>r|j<00>}tdt|<00><00>d|<04>d|<05><00><06><00>|j
r|jd|j
<00>|jr|jd|j<00>|j
S) 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%s<>capture_outputTzThe command
z,
failed and generated the following output:
z
and the following error:
z
stdout:
%sz
stderr:
%s) <0B>debugr<67><00>
subprocess<EFBFBD>run<75>
returncode<EFBFBD>stdoutrR<00>bytes<65>decode<64>stderrr7)r<><00>loggerr<72><00>procr<63>r<>s r<00>_check_and_log_subprocessr<73>gs<><00><00> <0B>L<EFBFBD>L<EFBFBD><14>*<2A>7<EFBFBD>3<>4<> <15>><3E>><3E>'<27> A<>$<24> A<>&<26> A<>D<EFBFBD> <0B><EFBFBD><EFBFBD><15><1B><1B><06> <15>f<EFBFBD>e<EFBFBD> $<24><1B>]<5D>]<5D>_<EFBFBD>F<EFBFBD><15><1B><1B><06> <15>f<EFBFBD>e<EFBFBD> $<24><1B>]<5D>]<5D>_<EFBFBD>F<EFBFBD><1A><13>&<26>w<EFBFBD>/<2F>0<>1;<3B><15>h<EFBFBD>)<29><15>h<EFBFBD>  <18><19> <19> <0C>{<7B>{<7B><0E> <0C> <0C>]<5D>D<EFBFBD>K<EFBFBD>K<EFBFBD>0<> <0B>{<7B>{<7B><0E> <0C> <0C>]<5D>D<EFBFBD>K<EFBFBD>K<EFBFBD>0<> <0F>;<3B>;<3B>rc<00>v<00> tj<00>y#t$rtjd<01>YywxYw)zS
Perform OS-dependent setup when Matplotlib creates a new GUI application.
rN)r<00>-Win32_GetCurrentProcessExplicitAppUserModelID<49>OSError<6F>-Win32_SetCurrentProcessExplicitAppUserModelIDr rr<00>_setup_new_guiappr<70><00>s3<00><00><1A><19>G<>G<>I<><49> <12><1A><19>G<>G<> <18> <1A><1A>s <00><00>8<03>8c<00>V<00>|d|<01>d<02><03>jd<03>jd<01>xsdS)z<>
Format the number with at most the number of decimals given as precision.
Remove trailing zeros and possibly the decimal point.
<20>.<2E>f<>0)<01>rstrip)<02>number<65> precisions r<00>_format_approxr<78><00>s2<00><00>
<15>Q<EFBFBD>y<EFBFBD>k<EFBFBD><11>N<EFBFBD> #<23> +<2B> +<2B>C<EFBFBD> 0<> 7<> 7<><03> <<3C> C<><03>Crc
<00>V<00>tj|<00>sy|dk(r$|dk(ryttj|<00><00>}t d|r4tj tjt|<00><00><00>dzndtj tj|<01><00>z
<00>S)z
Return the number of significant digits to %g-format *value*, assuming that
it is known with an error of *delta*.
rr&r<>)r;r><00>absr<00>spacingr*<00>floor<6F>log10)rl<00>deltas r<00> _g_sig_digitsr<73><00>s<><00><00> <10>=<3D>=<3D><15> <1F><10> <0C><01>z<EFBFBD> <10>A<EFBFBD>:<3A><15><14>B<EFBFBD>J<EFBFBD>J<EFBFBD>u<EFBFBD>%<25>&<26><05> <0F> <09>38<33><14><1A><1A>D<EFBFBD>J<EFBFBD>J<EFBFBD>s<EFBFBD>5<EFBFBD>z<EFBFBD>*<2A> +<2B>a<EFBFBD> /<2F>a<EFBFBD>
<0E>*<2A>*<2A>T<EFBFBD>Z<EFBFBD>Z<EFBFBD><05>&<26>
'<27> (<28> )<29>)rc<00>L<00>|r|j<00>r|S|j<00>}|jd<01>r|dd}|jd<04>r|jdd<05>}|j d<06>r|dd}t
j dk(r|d k(rd
}d d d d<0E>j||<02>}|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``.
<20>kp_r&N<>page_<65>page)<02>_l<5F>_rr!<00>darwin<69>meta<74>cmd<6D>enter<65>pageup<75>pagedown)<03>return<72>priorr<72>)<08> isprintabler <00>
startswithr<EFBFBD>r<>r-<00>platformr/)<03>unikey<65>keysymrks r<00>_unikey_or_keysym_to_mplkeyr<79><00>s<><00><00><0E>&<26>$<24>$<24>&<26><15> <0A>
<10>,<2C>,<2C>.<2E>C<EFBFBD>
<EFBFBD>~<7E>~<7E>e<EFBFBD><1C><11>!<21>"<22>g<EFBFBD><03>
<EFBFBD>~<7E>~<7E>g<EFBFBD><1E><11>k<EFBFBD>k<EFBFBD>'<27>6<EFBFBD>*<2A><03>
<EFBFBD>|<7C>|<7C>L<EFBFBD>!<21><11>#<23>2<EFBFBD>h<EFBFBD><03>
<EFBFBD>|<7C>|<7C>x<EFBFBD><1F>C<EFBFBD>6<EFBFBD>M<EFBFBD><13><03><19><19><1A> <06>
<EFBFBD>c<EFBFBD>#<23>s<EFBFBD>m<EFBFBD> <08>
<0F>Jrc<00>b<00><00><01><02>tj<00><02><01>fd<01><08>}<03>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.
c<00><><00><03><02>t|<00><05>r|S|<00>G<00><03><02><04>fd<01>d<02><05><02>}<01>j<00>j<00>x|_|_<00><03> t |<01><03><02>|S)Nc<00>8<00><04>eZdZW<00>jZ<01><00><01><02>fd<01>Zy)<03>:_make_class_factory.<locals>.class_factory.<locals>.subclsc<00>:<00><04>t<00><04><03><01>f|j<00>fSr
)<02>_picklable_class_constructorr<72>)r<00> attr_name<6D>
base_class<EFBFBD>fmt<6D> mixin_classs <20><><EFBFBD><EFBFBD>r<00>
__reduce__zE_make_class_factory.<locals>.class_factory.<locals>.subcls.__reduce__<5F>s(<00><><00>4<>$<24>c<EFBFBD>9<EFBFBD>j<EFBFBD>A<><1C>)<29>)<29>+<2B>-<2D>-rN)rrrr<>)r<>r<>r<>r<>s<00><><EFBFBD><EFBFBD>r<00>subclsr<73><00>s<00><><00>$<24>/<2F>/<2F>J<EFBFBD> -<2D> -rr<>)rGrYrrr<>)<06>
axes_classr<EFBFBD>r<>r<>r<>r<>s @<40><><EFBFBD>r<00> class_factoryz*_make_class_factory.<locals>.class_factory<72>sf<00><><00> <16>j<EFBFBD>+<2B> .<2E><1D> <1D> <20>
<EFBFBD> -<2D> -<2D>[<5B>*<2A> -<2D>14<31>
<EFBFBD>
<EFBFBD>:<3A>;N<>;N<>0O<30>O<><06><0F>&<26>-<2D> <14> <20> <13>F<EFBFBD>I<EFBFBD>z<EFBFBD> 2<><15> r)r<><00>cacher)r<>r<>r<>rs``` r<00>_make_class_factoryr<00>s1<00><><00>&<0F>_<EFBFBD>_<EFBFBD><16><15><16>. +<2B>5<>5<>M<EFBFBD><1C> <18>rc<00>N<00>t|||<02>}||<03>}|j|<05>S)z(Internal helper for _make_class_factory.)r<00>__new__)r<>r<>r<>r<><00>factoryrs rr<>r<> s)<00><00>!<21>+<2B>s<EFBFBD>I<EFBFBD>><3E>G<EFBFBD>
<11>*<2A>
<1D>C<EFBFBD> <0E>;<3B>;<3B>s<EFBFBD> <1B>rc<00><><00> tjjd<01>j}t |t <00>xr t ||<01>S#t$rYywxYw)z'Return whether *x* is a PyTorch Tensor.<2E>torchF)r-r.r/<00>Tensorr0rRr<00>r<>r<>s r<00>_is_torch_arrayr
 sU<00><00><15><11>[<5B>[<5B>_<EFBFBD>_<EFBFBD>W<EFBFBD> %<25> ,<2C> ,<2C><02> <17>r<EFBFBD>4<EFBFBD> <20> "<22><1A>1<EFBFBD>b<EFBFBD>!<21>#<23><> <1A><15><14><15><><00>)A <00> A<03>Ac<00><><00> tjjd<01>j}t |t <00>xr t ||<01>S#t$rYywxYw)z"Return whether *x* is a JAX Array.<2E>jaxF)r-r.r/<00>Arrayr0rRrr s r<00> _is_jax_arrayr sU<00><00><15><11>[<5B>[<5B>_<EFBFBD>_<EFBFBD>U<EFBFBD> #<23> )<29> )<29><02> <17>r<EFBFBD>4<EFBFBD> <20> "<22><1A>1<EFBFBD>b<EFBFBD>!<21>#<23><> <1A><15><14><15>r c<00><><00> tjjd<01>j}t |t <00>xr t ||<01>S#t$rYywxYw)z#Check if *x* is a Pandas DataFrame.<2E>pandasF)r-r.r/<00> DataFramer0rRrr s r<00>_is_pandas_dataframer# sU<00><00><15><11>[<5B>[<5B>_<EFBFBD>_<EFBFBD>X<EFBFBD> &<26> 0<> 0<><02> <17>r<EFBFBD>4<EFBFBD> <20> "<22><1A>1<EFBFBD>b<EFBFBD>!<21>#<23><> <1A><15><14><15>r c<00><><00> tjjd<01>j} ||<00>S#t$rYywxYw#t
$rYywxYw)z6Return whether *x* is a TensorFlow Tensor or Variable.<2E>
tensorflowF)r-r.r/<00> is_tensorr0r<>)r<>rs r<00>_is_tensorflow_arrayr/ sW<00><00><15> <18>K<EFBFBD>K<EFBFBD>O<EFBFBD>O<EFBFBD>L<EFBFBD>1<>;<3B>;<3B> <09><15><18><11>|<7C><1B><> <1A><15><14><15><> <15><15><14><15>s<00>)4<00>A<00> A<03>A<03> A<03>Ac<00><><00>t|tj<00>r|St|d<01>r|j <00>St|d<02>r(|j
}t|tj<00>r|St |<00>st|<00>s t|<00>r1tj|<00>}t|tj<00>r|S|S)zDInternal helper to extract data from e.g. pandas and xarray objects.r/r;)
rRrr<>r<>r/r;r
rrr<>)r<><00>xtmps rr r @ s<><00><00><11>!<21>R<EFBFBD>Z<EFBFBD>Z<EFBFBD> <20><10><08><0E>q<EFBFBD>*<2A><1D><10>z<EFBFBD>z<EFBFBD>|<7C><1B><0E>q<EFBFBD>(<28><1B><10>x<EFBFBD>x<EFBFBD><04> <16>d<EFBFBD>B<EFBFBD>J<EFBFBD>J<EFBFBD> '<27><17>K<EFBFBD><16>q<EFBFBD><19>]<5D>1<EFBFBD>-<2D>1E<31>a<EFBFBD>1H<31>
<12>z<EFBFBD>z<EFBFBD>!<21>}<7D><04> <16>d<EFBFBD>B<EFBFBD>J<EFBFBD>J<EFBFBD> '<27><17>K<EFBFBD> <0C>Hrc<00>\<00> ||fzS#ttf$r|j|<01>cYSwxYw)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 {}'
)r[r<>rY)r<>rls r<00>_auto_format_strr[ s6<00><00>*!<21><12>e<EFBFBD>X<EFBFBD>~<7E><1D><> <15>z<EFBFBD> "<22>!<21><12>z<EFBFBD>z<EFBFBD>%<25> <20> <20>!<21>s <00><00> +<03>+)r FN)r N)T)F)g<00>?NNF)r<>Nr
)nrr4<00>collections.abcr<63>r<>r<>r<>r;<00>operatorr<72><00>pathlibrr<>r<>r-rVrFrPrY<00>numpyr<00>numpy.exceptionsr<00> ImportErrorrrrrrDrHrJr^r`ryr|r<><00>MatplotlibDeprecationWarningr<67>r<>r<>r<>r<>r<>rrrr rrr@r<>r[r]r<>r<>r<>r<>r<>r<><00> ls_mapperr<72><00> ls_mapper_rrrrr r<>rr%r'r)<00>STEP_LOOKUP_MAPr1r8r?rBrPr<>r_r<>r*<00>
attrgetterrerhrjrorxr<>r<>r5<00>
MutableSetr<EFBFBD>r<>r<>r<>r<>r<>r<>r<>r<>r<>rrr<>r
rrrr r)rfrgs00r<00><module>r(s<><00><01><04>
<13><16><11><10> <0B><10> <0B><0F> <09><18> <0C><11>
<EFBFBD> <0B><10> <0C><0E><12>0<>:<3A><12>.<2E>&<26>&<26>./<10>d<1E><1F><1F>$ <20>4<14>4<14>nC"<22>C"<22>L%<25>$<24>%<25>H<19>5<>5<> <0F> <0A>.(<28>(1<>
<15>1<0E>h8<> 8<>
<19>83<>-<2D>.<2E>,4H<01>4H<01>n <0E>%(<28>J<EFBFBD>J<EFBFBD>e<EFBFBD>B"<22>Jl8<>l8<>^-<2D>-<2D>(/<2F>0J<11>Z><11>B+0<>#<12>LF<14>T<1A><18><19><18> J<> <09> )<29><0F><0F> 1<>2<><04><01>1<EFBFBD>q<EFBFBD>!<21>t<EFBFBD>2<> <0B>*<2A>4
<18>$<24> <11>9<16>x_<13>D#<11>L!<11>H#<11>L2<>*<2A> .<2E>!0<> .<2E> 0<><0F> N<01>F<1B>($'<27>N<17>5<0F>p <0C><1A><1A>#<1B><1B>#<1B>P&<26>I<EFBFBD>%<25>%<25>c<EFBFBD>/B<>x<EFBFBD>/B<>/B<>8<EFBFBD>/L<>M<>
*<2A>-<2D>5<>$<07>N/<<3C>d.5<>b <0C><1A><1A>()<29><1B>()<29>V <20>+<2B>/<2F>/<2F>,<2C>,<2C> <20>2<10>$<12>((<28>$K<01> <17>B <1A>D<01>)<29>6<0F>8 <0B><1F><1F>+<19><11>+<19>\<1C> #<23> #<23> #<23><15>" <0A>6!<21><>I<13>0<>/<2F>/<2F>0<><30>z'3s<00>H1<00>. I<06>1 I<03>?I
Reference in a new issue Copy permalink