§ óŽ’jÝEãó<—dZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z mZmZm Z mZmZmZmZGd„d¦«Ze¦«ZGd„de¦«ZGd „d ¦«ZGd„d¦«Zd „Zd„Zd„Zd„Zefd„Zd„Zdd„Zd„Z d„Z!d„Z"d„Z#dd„Z$dS)a+ Helper functions for managing the Matplotlib API. This documentation is only relevant for Matplotlib developers, not for users. .. warning:: This module and its submodules are for internal use only. Do not use them in your own code. We may change the API at any time with no warning. éNé) Ú deprecatedÚwarn_deprecatedÚrename_parameterÚdelete_parameterÚmake_keyword_onlyÚdeprecate_method_overrideÚdeprecate_privatize_attributeÚ'suppress_matplotlib_deprecation_warningÚMatplotlibDeprecationWarningcó—eZdZd„ZdS)Ú_Unsetcó—dS)Nz©©Úselfs úFC:\Projects\DSCons\.venv\Lib\site-packages\matplotlib\_api\__init__.pyÚ__repr__z_Unset.__repr__!s€ØˆyóN)Ú__name__Ú __module__Ú__qualname__rrrrrr s#€€€€€ðððððrrcó—eZdZdZdS)ÚUnsupportedErrorzž Raised on inherited methods if the child class does not support the functionality of the base class. See `.unsupported_method` for details. N)rrrÚ__doc__rrrrr&s€€€€€ððððrrcó$—eZdZdZddœd„Zd„ZdS)Úunsupported_methoda Descriptor that creates a method raising `.UnsupportedError`. Historically, we have quite a few cases of inheritance hierarchies that do not fully respect the Liskov Substitution Principle, e.g. Axes and Artist. Some of the methods of a base class may not be implemented in the child class. In that case, we override the method in the child class to raise `.UnsupportedError`. Use in a class body to mark inherited methods as unsupported:: class Axes3D(Axes): twinx = _api.unsupported_method() Calling ``Axes3D().twinx()`` will raise "UnsupportedError: Axes3D does not support 'twinx'." Parameters ---------- append_message : str Optional additional text to be appended to the error message. N©Úappend_messagecó—||_dS©Nr)rrs rÚ__init__zunsupported_method.__init__Es€Ø,ˆÔÐÐrcó¾‡—|j›d|›dŠ|jr ‰d|jzz Šˆfd„}||_|j›d|›|_|j|_t |||¦«dS)Nz does not support 'z'.ú có"•—t‰¦«‚r!)r)rÚargsÚkwargsÚmessages €rÚmethodz/unsupported_method.__set_name__..methodMsø€Ý" 7Ñ+Ô+Ð+rú.)rrrrÚsetattr)rÚownerÚnamer)r(s @rÚ__set_name__zunsupported_method.__set_name__Hs–ø€Ø”^Ð@Ð@¸Ð@Ð@Ð@ˆØÔð 1Øs˜TÔ0Ñ0Ñ0ˆGð ,ð ,ð ,ð ,ð ,ðˆŒØ!&Ô!3Ð<Ð<°dÐ<Ð<ˆÔØ!Ô,ˆÔÝt˜VÑ$Ô$Ð$Ð$Ð$r)rrrrr"r.rrrrr/sK€€€€€ððð**.ð-ð-ð-ð-ð-ð%ð%ð%ð%ð%rrcó6—eZdZdZdd„Zd„Zed„¦«ZdS)Ú classpropertya$ Like `property`, but also triggers on access via the class, and it is the *class* that's passed as argument. Examples -------- :: class C: @classproperty def foo(cls): return cls.__name__ assert C.foo == "C" Ncód—||_|€|td¦«‚||_||_||_dS)Nz#classproperty only implements fget.)Ú_fgetÚ ValueErrorÚfsetÚfdelÚ_doc)rÚfgetr4r5Údocs rr"zclassproperty.__init__gs<€ØˆŒ ØÐ˜tÐ/ÝÐBÑCÔCÐCØˆŒ ØˆŒ àˆŒ ˆ ˆ rcó,—| |¦«Sr!©r2)rÚinstancer,s rÚ__get__zclassproperty.__get__ps€ØzŠz˜%Ñ Ô Ð rcó—|jSr!r:rs rr7zclassproperty.fgetss €àŒzÐr)NNN)rrrrr"r<Úpropertyr7rrrr0r0Vs\€€€€€ððð ðððð!ð!ð!ðððñ„Xðððrr0cól‡—td¦«Št|t¦«r|fn|€‰fntˆfd„|D¦«¦«}ˆfd„}| ¦«D]Ñ\}}t||¦«s¼gt ||¦«¢}d|vr*| d¦«| d¦«td |t|¦«dkr)d |dd…¦«d z|dzn|d |t|¦«¦«¦«¦«‚ŒÒdS)a3 For each *key, value* pair in *kwargs*, check that *value* is an instance of one of *types*; if not, raise an appropriate TypeError. As a special case, a ``None`` entry in *types* is treated as NoneType. Examples -------- >>> _api.check_isinstance((SomeClass, None), arg=arg) Nc3ó$•K—|] }|€‰n|V—ŒdSr!r)Ú.0ÚtpÚ none_types €rú z#check_isinstance..‰s+øèè€ÐCÐC°r 99°ÐCÐCÐCÐCÐCÐCrcóV•—|‰urdn"|jdkr|jn|j›d|j›S)NÚNoneÚbuiltinsr*)rr)rBrCs €rÚ type_namez#check_isinstance..type_name‹s=ø€Ø ˜/˜/Ø(*¬ ¸Ò(CÐ(CR”__Øœ Ð9Ð9¨¬Ð9Ð9ð ;rrFz({!r} must be an instance of {}, not a {}rú, éÿÿÿÿz or r)ÚtypeÚ isinstanceÚtupleÚitemsÚmapÚremoveÚappendÚ TypeErrorÚformatÚlenÚjoin)Útypesr'rHÚkÚvÚnamesrCs @rÚcheck_isinstancerZ{slø€õT‘ ” €IÝ# E4Ñ0Ô0ðDˆeˆXˆXØ"˜]ˆiˆ\ˆ\Ý ÐCÐCÐCÐC¸UÐCÑCÔCÑ CÔ Cð ð;ð;ð;ð;ð;ð —’‘”ð)ð)‰ˆˆ1Ý˜!˜UÑ#Ô#ð )Ø,•c˜) UÑ+Ô+Ð,ˆEØ˜ˆˆØ—’˜VÑ$Ô$Ð$Ø—’˜VÑ$Ô$Ð$ÝØ:×AÒAØå˜5‘z”z A’~~ð—I’I˜e C R CœjÑ)Ô)¨FÑ2°U¸2´YÑ>Ð>Ø+0°¬8ØId 1™gœgÑ&Ô&ñ (ô(ñ)ô)ð )ð )ð)ð)rcó¨—t|¦«dkr‹td„|g|¢D¦«¦«rotj||d¬¦«}t|¦«xdkrd}nkdkr d|d›d }nY d d tt|¦«¦«›d }n+dd tt|¦«¦«›}|›d |›d|›S)a Generate an error message that a potential setting is not an acceptable value. If the acceptable values are all strings, and sufficiently large, then add just a few suggestions to the end of the message. Otherwise list the supported values. Parameters ---------- name : str The name of the setting, keyword argument, etc. to generate the message for. potential The potential value from the user that is not a valid choice. values : iterable Sequence of values to check on. éc3ó@K—|]}t|t¦«V—ŒdSr!)rLÚstr)rArXs rrDz,list_suggestion_error_msg..®s,èè€ÐPÐP°az¨!SÑ1Ô1ÐPÐPÐPÐPÐPÐPrgà?)ÚcutoffrÚrz Did you mean: Ú?z Did you mean one of: rIz Supported values are z is not a valid value for r*)rTÚallÚdifflibÚget_close_matchesrUrOÚrepr)r-Ú potentialÚvaluesÚbestÚ suggestions rÚlist_suggestion_error_msgrjžsí€õ ˆ6{„{Q‚€3ÐPÐP¸IÐ;OÈÐ;OÐPÑPÔPÑPÔP€ÝÔ(¨°FÀ3ÐGÑGÔGˆÝ$‰iŒiØ’Ø Ø’Ø;¨t°A¬wÐ;Ð;Ð; ØØS°d·i²iÅÅDÈ$ÁÄÑ6PÔ6PÐSÐSÐS àL¨d¯iªi½½DÀ&Ñ8IÔ8IÑ.JÔ.JÐLÐLˆ ØÐHÐH°TÐHÐH¸JÐHÐHÐHrcóÌ—|std¦«‚| ¦«D]=\}} ||v}n#t$rd}YnwxYw|stt|||¦«¦«‚Œ>dS)a| For each *key, value* pair in *kwargs*, check that *value* is in *values*; if not, raise an appropriate ValueError. Parameters ---------- values : iterable Sequence of values to check on. Note: All values must support == comparisons. This means in particular the entries must not be numpy arrays. **kwargs : dict *key, value* pairs as keyword arguments to find in *values*. Raises ------ ValueError If any *value* in *kwargs* is not found in *values*. Examples -------- >>> _api.check_in_list(["foo", "bar"], arg=arg, other_arg=other_arg) zNo argument to check!FN)rRrNr3rj)rgr'ÚkeyÚvalÚexistss rÚ check_in_listro¼s¦€ð0ð1ÝÐ/Ñ0Ô0Ð0Ø—L’L‘N”Nð Jð J‰ˆˆSð Ø˜F]ˆFˆFøÝð ð ð ðˆFˆFˆFð øøøðð JÝÕ6°s¸CÀÑHÔHÑIÔIÐIð Jð Jð Js¬1±A¿Ac óD‡—| ¦«D]\}}|j}t|¦«t|¦«ks'td„t ||¦«D¦«¦«r´tt jdd„t j¦«D¦«¦«¦«Šd ˆfd„|ddd…D¦«ddd…¦«}t|¦«dkr|d z }t|›d t|¦«›d|›d|j›¦«‚Œ dS) a¦ For each *key, value* pair in *kwargs*, check that *value* has the shape *shape*; if not, raise an appropriate ValueError. *None* in the shape is treated as a "free" size that can have any length. e.g. (None, 2) -> (N, 2) The values checked must be numpy arrays. Examples -------- To check for (N, 2) shaped arrays >>> _api.check_shape((None, 2), arg=arg, other_arg=other_arg) c3ó0K—|]\}}||ko|duV—ŒdSr!r)rAÚsÚts rrDzcheck_shape..ús3èè€ÐSÐS±D°A°qq˜A’vÐ/ !¨4 -ÐSÐSÐSÐSÐSÐSrÚNMLKJIHc3ó K—|] }d|›V—Œ dS)ÚDNr)rAÚis rrDzcheck_shape..ýs(èè€Ð4Ð4˜QQÐ4Ð4Ð4Ð4Ð4Ð4rrIcóP•—g|]"}|t|¦«nt‰¦«‘Œ#Sr!)r^Únext)rAÚnÚ dim_labelss €rú zcheck_shape..þs?ø€ð$:ð$:ð$:Ø()ð/0¨m¥C¨¡F¤F FÅÀjÑAQÔAQð$:ð$:ð$:rNrJrú,z must be zD with shape (z), but your input has shape )rNÚshaperTÚanyÚzipÚiterÚ itertoolsÚchainÚcountrUr3)r~r'rWrXÚ data_shapeÚ text_shaper{s @rÚcheck_shaper‡æsjø€ð —’‘”ðñ‰ˆˆ1Ø”Wˆ å ‰OŒOs 5™zœzÒ)Ð)ÝÐSÐS½CÀ ÈEÑ¸$¸B¸$ô$@ñAôAˆJå5‰zŒz˜QŠˆØ˜cÑ! åØð6ð6¥ U¡¤ð6ð6¸:ð6ð6Ø,-¬Gð6ð6ñôð ñ *ððrc ó—t|¦«dkrtd¦«‚| ¦«\\}} ||S#t$r.|t ||| ¦«¦«¦«d‚wxYw)aE *kwargs* must consist of a single *key, value* pair. If *key* is in *mapping*, return ``mapping[value]``; else, raise an appropriate ValueError. Parameters ---------- _error_cls : Class of error to raise. Examples -------- >>> _api.getitem_checked({"foo": "bar"}, arg=arg) rz/getitem_checked takes a single keyword argumentN)rTr3rNÚKeyErrorrjÚkeys)ÚmappingÚ _error_clsr'rWrXs rÚgetitem_checkedr s€õˆ6{„{aÒÐÝÐJÑKÔKÐKØlŠl‰nŒnGF€QˆðTØqŒzÐøÝðTðTðTØˆjÕ2°1°a¸¿º¹¼ÑHÔHÑIÔIÈtÐSðTøøøs½AÁ8A=cóÂ‡‡‡—‰jdksJ‚d„t‰¦« ¦«D¦«Š‰¦«Štjˆˆˆfd„¦«}|S)a Helper decorator for implementing module-level ``__getattr__`` as a class. This decorator must be used at the module toplevel as follows:: @caching_module_getattr class __getattr__: # The class *must* be named ``__getattr__``. @property # Only properties are taken into account. def name(self): ... The ``__getattr__`` class will be replaced by a ``__getattr__`` function such that trying to access ``name`` on the module will resolve the corresponding property (which may be decorated e.g. with ``_api.deprecated`` for deprecating module globals). The properties are all implicitly cached. Moreover, a suitable AttributeError is generated and raised if no property with the given name exists. Ú__getattr__cóD—i|]\}}t|t¦«¯||“ŒSr)rLr>)rAr-Úprops rú z*caching_module_getattr..6s<€ð ,ð ,ð ,™J˜D $Ý˜4¥Ñ*Ô*ð ,ˆT4ð ,ð ,ð ,rcóv•—|‰vr‰| ‰¦«Std‰j›d|›¦«‚)Nzmodule z has no attribute )r<ÚAttributeErrorr)r-Úclsr;Úpropss €€€rrz+caching_module_getattr..__getattr__:sNø€à5ˆ=ˆ=Ø˜”;×&Ò& xÑ0Ô0Ð0ÝØBc”nÐBÐB¸$ÐBÐBñDôDð Dr)rÚvarsrNÚ functoolsÚcache)r•rr;r–s` @@rÚcaching_module_getattrrš!søøø€ð&Œ<˜=Ò(Ð(Ð(Ð(ð ,ð ,$¨s©)¬)¯/ª/Ñ*;Ô*;ð ,ñ ,ô ,€Eàˆs‰uŒu€Hå„_ðDðDðDðDðDðDñ„_ðDðÐrcó.‡—‰€tjt|¦«Sˆfd„}| ¦«D]u\}}d}dD]W}||zt ‰¦«vrAd}|D]<}|||z¦«}||z|_d||z›d|_t‰||z|¦«Œ=ŒX|std|›¦«‚Œvd „| ¦«D¦«} d „} t‰di¦«}| |¦«| | ¦«z}|rtd|›¦«‚i|¥| ¥‰_‰S) aQ Class decorator for defining property aliases. Use as :: @_api.define_aliases({"property": ["alias", ...], ...}) class C: ... For each property, if the corresponding ``get_property`` is defined in the class so far, an alias named ``get_alias`` will be defined; the same will be done for setters. If neither the getter nor the setter exists, an exception will be raised. The alias map is stored as the ``_alias_to_prop`` attribute under the format ``{"alias": "property", ...}` on the class, and can be used by `.normalize_kwargs`. Ncód•‡—tjt‰‰¦«¦«ˆfd„¦«}|S)Ncó0•—t|‰¦«|i|¤ŽSr!)Úgetattr)rr&r'r-s €rr)z2define_aliases..make_alias..methodZs"ø€à&•7˜4 Ñ&Ô&¨Ð7°Ð7Ð7Ð7r)r˜Úwrapsrž)r-r)r•s` €rÚ make_aliasz"define_aliases..make_aliasYsAøø€Ý Œ dÑ+Ô+Ñ ,Ô ,ð 8ð 8ð 8ð 8ñ -Ô ,ð 8àˆ rF)Úget_Úset_TzAlias for `z`.z%Neither getter nor setter exists for có$—i|] \}}|D]}||“ŒŒSrr)rAr‘ÚaliasesÚaliass rr’z"define_aliases..msH€ðOðOðOÙ%˜˜gÀgðOðOØ=BˆˆtðOðOðOðOrcóV—h| ¦«£| ¦«£Sr!)rŠrg)Úds rÚget_aliased_and_aliasesz/define_aliases..get_aliased_and_aliasesps"€Ø'—’‘”Ð'˜AŸHšH™JœJÐ'Ð'rÚ_alias_to_propz2Parent class already defines conflicting aliases: )r˜ÚpartialÚdefine_aliasesrNr—rrr+r3ržÚNotImplementedErrorr©) Úalias_dr•r r‘r¤rnÚprefixr¥r)Ú alias_to_propr¨Úpreexisting_aliasesÚconflictings ` rr«r«DsÃø€ð$€{ÝÔ ¥°Ñ9Ô9Ð9ðððððð!Ÿš™œðBðB‰ ˆˆgØˆØ&ð 9ð 9ˆFØ˜‰}¥ S¡ ¤ Ð)Ð)ØØ$ð9ð9EØ'˜Z¨°© Ñ6Ô6FØ&,¨u¡nF”OØ%D°6¸D±=Ð%DÐ%DÐ%DF”NÝ˜C ¨%¡°Ñ8Ô8Ð8Ð8øØð BÝØ@¸Ð@Ð@ñBôBð Bð BðOðOØ)0¯ª©¬ðOñOôO€Mð(ð(ð(õ" #Ð'7¸Ñ<Ô<ÐØ*Ð*Ð+>Ñ?Ô?Ø,Ð,¨]Ñ;Ô;ñ<€KàðPå!ØNÀÐNÐNñPôPð PàAÐ/ÐA°=ÐA€CÔØ€Jrcó’—t|¦«D]6\}} ||i|¤ŽcS#t$r|t|¦«dz kr‚YŒ3wxYwdS)a Select and call the function that accepts ``*args, **kwargs``. *funcs* is a list of functions which should not raise any exception (other than `TypeError` if the arguments passed do not match their signature). `select_matching_signature` tries to call each of the functions in *funcs* with ``*args, **kwargs`` (in the order in which they are given). Calls that fail with a `TypeError` are silently skipped. As soon as a call succeeds, `select_matching_signature` returns its return value. If no function accepts ``*args, **kwargs``, then the `TypeError` raised by the last failing call is re-raised. Callers should normally make sure that any ``*args, **kwargs`` can only bind a single *func* (to avoid any ambiguity), although this is not checked by `select_matching_signature`. Notes ----- `select_matching_signature` is intended to help implementing signature-overloaded functions. In general, such functions should be avoided, except for back-compatibility concerns. A typical use pattern is :: def my_func(*args, **kwargs): params = select_matching_signature( [lambda old1, old2: locals(), lambda new: locals()], *args, **kwargs) if "old1" in params: warn_deprecated(...) old1, old2 = params.values() # note that locals() is ordered. else: new, = params.values() # do things with params which allows *my_func* to be called either with two parameters (*old1* and *old2*) or a single one (*new*). Note that the new signature is given last, so that callers get a `TypeError` corresponding to the new signature if the arguments they passed in do not match any signature. rN)Ú enumeraterRrT)Úfuncsr&r'rwÚfuncs rÚselect_matching_signaturer¶~s…€õX˜UÑ#Ô#ðð‰ˆˆ4ð Ø4˜Ð( Ð(Ð(Ð(Ð(Ð(øÝð ð ð Ø•C˜‘J”J ‘NÒ"Ð"Øð#Ð"ð øøøððs– !AÁAcó2—t|›d|›d|›d¦«S)zEGenerate a TypeError to be raised by function calls with wrong arity.z () takes z positional arguments but z were given)rR)r-ÚtakesÚgivens rÚnargs_errorrº²s>€å˜ð+ð+ uð+ð+Øð+ð+ð+ñ,ô,ð,rcóŽ—t|t¦«stt|¦«¦«}t |›d|›d¦«S)aL Generate a TypeError to be raised by function calls with wrong kwarg. Parameters ---------- name : str The name of the calling function. kw : str or Iterable[str] Either the invalid keyword argument name, or an iterable yielding invalid keyword arguments (e.g., a ``kwargs`` dict). z'() got an unexpected keyword argument 'ú')rLr^ryrrR)r-Úkws rÚkwarg_errorr¾¸sF€õb#ÑÔðÝ •$r‘(”(‰^Œ^ˆÝ˜ÐJÐJÀRÐJÐJÐJÑKÔKÐKrc#ójK—|V—| ¦«D]}t|¦«Ed{V—†ŒdS)z8Yield *cls* and direct and indirect subclasses of *cls*.N)Ú__subclasses__Úrecursive_subclasses)r•Úsubclss rrÁrÁÉsWèè€à €I€I€IØ×$Ò$Ñ&Ô&ð0ð0ˆÝ'¨Ñ/Ô/Ð/Ð/Ð/Ð/Ð/Ð/Ð/Ð/ð0ð0rcóØ—i}tjdd…dkrLtjt¦«jd}t |dz¦«t |dz¦«f|d<nptj¦«}tj d¦«D]G}|€||d<n=tjd |j d d¦«¦«s||d<n|j}ŒH~tj||fi|¤ŽdS)a4 `warnings.warn` wrapper that sets *stacklevel* to "outside Matplotlib". The original emitter of the warning can be obtained by patching this function back to `warnings.warn`, i.e. ``_api.warn_external = warnings.warn`` (or ``functools.partial(warnings.warn, stacklevel=2)``, etc.). Né)ééÚ matplotlibÚmpl_toolkitsÚskip_file_prefixesrÚ stacklevelz-\A(matplotlib|mpl_toolkits)(\Z|\.(?!tests\.))rr`)ÚsysÚversion_infoÚpathlibÚPathÚ__file__Úparentsr^Ú _getframer‚r„ÚreÚmatchÚ f_globalsÚgetÚf_backÚwarningsÚwarn)r(Úcategoryr'ÚbasedirÚframerÊs rÚ warn_externalrÜÐs €ð€FÝ Ô˜˜˜Ô˜wÒ&Ð&å”,xÑ(Ô(Ô0°Ô3ˆÝ(+¨G°lÑ,BÑ(CÔ(CÝ(+¨G°nÑ,DÑ(EÔ(Eð(GˆÐ#Ñ$Ð$õ” ‘”ˆÝ#œ/¨!Ñ,Ô,ð !ð !ˆJØˆ}à'1|Ñ$ØÝ”8ÐLà!œO×/Ò/° ¸BÑ?Ô?ñAôAð ð(2|Ñ$ØØ”LˆEˆEàÝ„M'˜8Ð.Ð. vÐ.Ð.Ð.Ð.Ð.rr!)%rrcr˜r‚rÍrÒrËr×Údeprecationrrrrrr r rrrÚUNSETÚRuntimeErrorrrr0rZrjror‡r3rršr«r¶rºr¾rÁrÜrrrúràsZðð ð ð€€€ØÐÐÐØÐÐÐØ€€€Ø € € € Ø € € € Ø€€€ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ð"ðððððñôðð ˆ‰Œ€ððððð|ñôðð$%ð$%ð$%ð$%ð$%ñ$%ô$%ð$%ðNððððñôððJ )ð )ð )ðFIðIðIð<'Jð'Jð'JðT ð ð ðF,6ðTðTðTðTð0 ð ð ðF7ð7ð7ð7ðt1ð1ð1ðh,ð,ð,ðLðLðLð"0ð0ð0ð/ð/ð/ð/ð/ð/r