0Ph=dZddlZddlmZddlmZddlmZmZm Z ddl m Z ddl m Z dd lmZd d lmZgd Zd dgd dgdZeeezZdZdZdZGddZdZdZdZdddeegZdZdZ GddZ!Gdd Z"ed!d"d#gZ#ed$d%d&gZ$Gd'd(Z%Gd)d*Z&d4d+Z'd,Z(d-Z)d.Z*Gd/d0Z+Gd1d2Z,d3Z-dS)5a1 Metadata Routing Utility In order to better understand the components implemented in this file, one needs to understand their relationship to one another. The only relevant public API for end users are the ``set_{method}_request`` methods, e.g. ``estimator.set_fit_request(sample_weight=True)``. However, third-party developers and users who implement custom meta-estimators, need to deal with the objects implemented in this file. All estimators (should) implement a ``get_metadata_routing`` method, returning the routing requests set for the estimator. This method is automatically implemented via ``BaseEstimator`` for all simple estimators, but needs a custom implementation for meta-estimators. In non-routing consumers, i.e. the simplest case, e.g. ``SVM``, ``get_metadata_routing`` returns a ``MetadataRequest`` object. In routers, e.g. meta-estimators and a multi metric scorer, ``get_metadata_routing`` returns a ``MetadataRouter`` object. An object which is both a router and a consumer, e.g. a meta-estimator which consumes ``sample_weight`` and routes ``sample_weight`` to its sub-estimators, routing information includes both information about the object itself (added via ``MetadataRouter.add_self_request``), as well as the routing information for its sub-estimators. A ``MetadataRequest`` instance includes one ``MethodMetadataRequest`` per method in ``METHODS``, which includes ``fit``, ``score``, etc. Request values are added to the routing mechanism by adding them to ``MethodMetadataRequest`` instances, e.g. ``metadatarequest.fit.add(param="sample_weight", alias="my_weights")``. This is used in ``set_{method}_request`` which are automatically generated, so users and developers almost never need to directly call methods on a ``MethodMetadataRequest``. The ``alias`` above in the ``add`` method has to be either a string (an alias), or a {True (requested), False (unrequested), None (error if passed)}``. There are some other special values such as ``UNUSED`` and ``WARN`` which are used for purposes such as warning of removing a metadata in a child class, but not used by the end users. ``MetadataRouter`` includes information about sub-objects' routing and how methods are mapped together. For instance, the information about which methods of a sub-estimator are called in which methods of the meta-estimator are all stored here. Conceptually, this information looks like: ``` { "sub_estimator1": ( mapping=[(caller="fit", callee="transform"), ...], router=MetadataRequest(...), # or another MetadataRouter ), ... } ``` To give the above representation some structure, we use the following objects: - ``(caller=..., callee=...)`` is a namedtuple called ``MethodPair`` - The list of ``MethodPair`` stored in the ``mapping`` field of a `RouterMappingPair` is a ``MethodMapping`` object - ``(mapping=..., router=...)`` is a namedtuple called ``RouterMappingPair`` The ``set_{method}_request`` methods are dynamically generated for estimators which inherit from the ``BaseEstimator``. This is done by attaching instances of the ``RequestMethod`` descriptor to classes, which is done in the ``_MetadataRequester`` class, and ``BaseEstimator`` inherits from this mixin. This mixin also implements the ``get_metadata_routing``, which meta-estimators need to override, but it works for simple consumers as is. N) namedtuple)deepcopy) TYPE_CHECKINGOptionalUnion)warn) get_config)UnsetMetadataPassedError)Bunch) fit partial_fitpredict predict_probapredict_log_probadecision_functionscoresplit transforminverse_transformrrr) fit_transform fit_predictcFtddS)zReturn whether metadata routing is enabled. .. versionadded:: 1.3 Returns ------- enabled : bool Whether metadata routing is enabled. If the config is not set, it defaults to False. enable_metadata_routingF)r get`/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/utils/_metadata_requests.py_routing_enabledr ws <<  5u = ==rc|r|jjd|n |jj}ts$|r$td|dt |dSdS)aRaise an error if metadata routing is not enabled and params are passed. .. versionadded:: 1.4 Parameters ---------- params : dict The metadata passed to a method. owner : object The object to which the method belongs. method : str The name of the method, e.g. "fit". Raises ------ ValueError If metadata routing is not enabled and params are passed. .z#Passing extra keyword arguments to z is only supported if enable_metadata_routing=True, which you can set using `sklearn.set_config`. See the User Guide for more details. Extra parameters passed are: N) __class____name__r ValueErrorset)paramsownermethodcallers r_raise_for_paramsr+s,39V5? #..f...eo>V     &  D& D D7:&kk  D D       rc d|D}trH|rH|jj}t |d|dt |d|ddSdS)amRaise when metadata routing is enabled and metadata is passed. This is used in meta-estimators which have not implemented metadata routing to prevent silent bugs. There is no need to use this function if the meta-estimator is not accepting any metadata, especially in `fit`, since if a meta-estimator accepts any metadata, they would do that in `fit` as well. Parameters ---------- obj : estimator The estimator for which we're raising the error. method : str The method where the error is raised. **kwargs : dict The metadata passed to the method. ci|] \}}||| SNr).0keyvalues r z2_raise_for_unsupported_routing..s# O O OZS%U=Nc5=N=N=Nrr"z cannot accept given metadata (z4) since metadata routing is not yet implemented for N)itemsr r#r$NotImplementedErrorr&keys)objr)kwargscls_names r_raise_for_unsupported_routingr9s(P O6<<>> O O OF f =)! N N& N NV[[]]ASAS N NBJ N N N       rceZdZdZdZdS)_RoutingNotSupportedMixinzA mixin to be used to remove the default `get_metadata_routing`. This is used in meta-estimators where metadata routing is not yet implemented. This also makes it clear in our rendered documentation that this method cannot be used. c:t|jjd)z[Raise `NotImplementedError`. This estimator does not support metadata routing yet.z* has not implemented metadata routing yet.)r4r#r$selfs rget_metadata_routingz._RoutingNotSupportedMixin.get_metadata_routings'"~& R R R   rN)r$ __module__ __qualname____doc__r?rrrr;r;s-     rr;z$UNUSED$z$WARN$z $UNCHANGED$FTcj|tvrdSt|to|S)avCheck if an item is a valid alias. Values in ``VALID_REQUEST_VALUES`` are not considered aliases in this context. Only a string which is a valid identifier is. Parameters ---------- item : object The given item to be checked if it can be an alias. Returns ------- result : bool Whether the given item is a valid alias. F)VALID_REQUEST_VALUES isinstancestr isidentifieritems rrequest_is_aliasrJs8  ###u dC 8T%6%6%8%88rc|tvS)zCheck if an item is a valid request value (and not an alias). Parameters ---------- item : object The given item to be checked. Returns ------- result : bool Whether the given item is valid. )rDrHs rrequest_is_validrLs ' ''rc`eZdZdZd dZedZdZdZdZ dZ d Z d Z d Z d ZdS)MethodMetadataRequestaA prescription of how metadata is to be passed to a single method. Refer to :class:`MetadataRequest` for how this class is used. .. versionadded:: 1.3 Parameters ---------- owner : str A display name for the object owning these requests. method : str The name of the method to which these requests belong. requests : dict of {str: bool, None or str}, default=None The initial requests for this method. NcL|p t|_||_||_dSr.)dict _requestsr(r))r>r(r)requestss r__init__zMethodMetadataRequest.__init__-s$!+TVV  rc|jS)z)Dictionary of the form: ``{key: alias}``.rQr=s rrRzMethodMetadataRequest.requests2s ~rct|s%t|std|d|d||krd}|tkr%||jvr |j|=ntd|d||j|<|S)aAdd request info for a metadata. Parameters ---------- param : str The property for which a request is set. alias : str, or {True, False, None} Specifies which metadata should be routed to `param` - str: the name (or alias) of metadata given to a meta-estimator that should be routed to this parameter. - True: requested - False: not requested - None: error if passed zThe alias you're setting for `zZ` should be either a valid identifier or one of {None, True, False}, but given value is: ``TzTrying to remove parameter z! with UNUSED which doesn't exist.)rJrLr%UNUSEDrQ)r>paramaliass r add_requestz!MethodMetadataRequest.add_request7s2 && /?/F/F '''#'''  E>>E F??&&N5)) % %*DN5 ! rchtfd|jDS)aGet names of all metadata that can be consumed or routed by this method. This method returns the names of all metadata, even the ``False`` ones. Parameters ---------- return_alias : bool Controls whether original or aliased names should be returned. If ``False``, aliases are ignored and original names are returned. Returns ------- names : set of str A set of strings with the names of all parameters. c3nK|]/\}}t|r|durt|s|n|V0dS)FN)rL)r/proprZ return_aliass r z9MethodMetadataRequest._get_param_names..xsg  e#E** /45.@.@" K*:5*A*A KEEt.@.@.@.@  r)r&rQr3)r>r_s `r_get_param_namesz&MethodMetadataRequest._get_param_namesgsK"    #~3355      rc infd|jD}|D] }td|d|jd|d!dS)zCheck whether metadata is passed which is marked as WARN. If any metadata is passed which is marked as WARN, a warning is raised. Parameters ---------- params : dict The metadata passed to a method. Nc8h|]\}}|tk|v|Sr)WARN)r/r^rZr's r z8MethodMetadataRequest._check_warnings..s6   e}} !/rz Support for zj has recently been added to this class. To maintain backward compatibility, it is ignored now. Using `set_z _request(z={True, False})` on this method of the class, you can set the request value to False to silence this warning, or to True to consume and use the metadata.)rQr3rr))r>r' warn_paramsrYs ` r_check_warningsz%MethodMetadataRequest._check_warnings~s~6    #~3355   !  E $u$$"k$$49$$$      rc ||t}d|D}t}|jD]J\}}|dus |t kr|dur||vr ||||<)|||vr ||||<;||vr ||||<K|r|jtvrt|j} n|jg} dd| D} dd d |Dd |j d |jd |d |d|j | zdz} t| |||S)aPrepare the given parameters to be passed to the method. The output of this method can be used directly as the input to the corresponding method as extra props. Parameters ---------- params : dict A dictionary of provided metadata. parent : object Parent class object, that routes the metadata. caller : str Method from the parent class object, where the metadata is routed from. Returns ------- params : Bunch A :class:`~sklearn.utils.Bunch` of {prop: value} which can be given to the corresponding method. r'ci|] \}}||| Sr.r)r/argr1s rr2z7MethodMetadataRequest._route_params..s#QQQzsEu?PU?P?P?PrFTNcg|]}d|d S)z.set_z_request({metadata}=True/False)rr/r)s r z7MethodMetadataRequest._route_params..s4FFEEEr[, cg|]}|Srr)r/r0s rroz7MethodMetadataRequest._route_params..s:::ss:::rzJ] are passed but are not explicitly set as requested or not requested for r"z, which is used within z. Call `z/` for each metadata you want to request/ignore.)messageunrequested_params routed_params) rgrPr3r rQrdr)COMPOSITE_METHODSjoinr(r ) r>r'parentr* unrequestedargsresr^rZcallee_methodsset_requests_onrss r _route_paramsz#MethodMetadataRequest._route_paramss. F+++ff QQV\\^^QQQgg>//11 ( (KD%~~$$44<< JD 44<<$(J D!!$ KD  {///!24;!?"&+ gg"0O:DII::k:::;;::J::!%::::$::.2Z::" " D D +#.!   rct|}t}|jD]Q\}}|dur||vr||#t |t r||vr||R|S)aBCheck whether the given parameters are consumed by this method. Parameters ---------- params : iterable of str An iterable of parameters to check. Returns ------- consumed : set of str A set of parameters which are consumed by this method. T)r&rQr3addrErF)r>r'r{r^rZs r _consumeszMethodMetadataRequest._consumessVee>//11  KD%}} E3'' EVOO rc|jSSerialize the object. Returns ------- obj : dict A serialized version of the instance in the form of a dictionary. rUr=s r _serializez MethodMetadataRequest._serializes ~rcDt|Sr.rFrr=s r__repr__zMethodMetadataRequest.__repr__4??$$%%%rc:tt|Sr.rFreprr=s r__str__zMethodMetadataRequest.__str__4::rr.)r$r@rArBrSpropertyrRr[rargr~rrrrrrrrNrNs$ X...`   .4<<<|,&&&rrNcNeZdZdZdZdZdZdZd dZdZ d Z d Z d Z d Z dS)MetadataRequestaContains the metadata request info of a consumer. Instances of `MethodMetadataRequest` are used in this class for each available method under `metadatarequest.{method}`. Consumer-only classes such as simple estimators return a serialized version of this class as the output of `get_metadata_routing()`. .. versionadded:: 1.3 Parameters ---------- owner : str The name of the object to which these requests belong. metadata_requestc h||_tD]"}t||t||#dS)Nr(r))r(SIMPLE_METHODSsetattrrN)r>r(r)s rrSzMetadataRequest.__init__sO $  F %E&AAA      rcJt|||S)Check whether the given parameters are consumed by the given method. .. versionadded:: 1.4 Parameters ---------- method : str The name of the method to check. params : iterable of str An iterable of parameters to check. Returns ------- consumed : set of str A set of parameters which are consumed by the given method. ri)getattrrr>r)r's rconsumeszMetadataRequest.consumess%$tV$$..f.===rc L|tvr td|jjd|dit|D]}t ||t }t j}||z}fd|D}|rJtdd |d|dd t|d j t|j | S) N'z' object has no attribute 'cBg|]}|j|k|SrrU)r/r0mmrrRs rroz/MetadataRequest.__getattr__..Cs/VVV(3-3=QTCU2U2U2U2U2Urz"Conflicting metadata requests for rqz" while composing the requests for z*. Metadata with the same name for methods z$ should have the same request value.)r(r)rR)rvAttributeErrorr#r$rr&r5rRr%rwupdaterQrNr() r>namer)existingupcomingcommon conflictsrrRs @@r __getattr__zMetadataRequest.__getattr__0sW ( ( ( ODN+OOOOO '- + +F$''C8==??++H3<,,..//H(FVVVVVVVVI  +99M9M++37++$(II.?.E$F$F+++ OOCM * * * *$4:dXVVVVrNcJt|||S)aGet names of all metadata that can be consumed or routed by specified method. This method returns the names of all metadata, even the ``False`` ones. Parameters ---------- method : str The name of the method for which metadata names are requested. return_alias : bool Controls whether original or aliased names should be returned. If ``False``, aliases are ignored and original names are returned. ignore_self_request : bool Ignored. Present for API compatibility. Returns ------- names : set of str A set of strings with the names of all parameters. )r_)rra)r>r)r_ignore_self_requests rraz MetadataRequest._get_param_namesNs%0tV$$55<5PPPrcNt|||||S)a*Prepare the given parameters to be passed to the method. The output of this method can be used directly as the input to the corresponding method as extra keyword arguments to pass metadata. Parameters ---------- params : dict A dictionary of provided metadata. method : str The name of the method for which the parameters are requested and routed. parent : object Parent class object, that routes the metadata. caller : str Method from the parent class object, where the metadata is routed from. Returns ------- params : Bunch A :class:`~sklearn.utils.Bunch` of {prop: value} which can be given to the corresponding method. )r'rxr*)rr~)r>r'r)rxr*s rr~zMetadataRequest._route_paramshs26tV$$22&3   rcNt|||dS)a`Check whether metadata is passed which is marked as WARN. If any metadata is passed which is marked as WARN, a warning is raised. Parameters ---------- method : str The name of the method for which the warnings should be checked. params : dict The metadata passed to a method. riN)rrgrs rrgzMetadataRequest._check_warningss+ f--V-<<<<|Sr)rPrrlenrRr)r>outputr)rs rrzMetadataRequest._serializesV$ 2 2F$''C3<   2!$!1!1v rcDt|Sr.rr=s rrzMetadataRequest.__repr__rrc:tt|Sr.rr=s rrzMetadataRequest.__str__rrr.)r$r@rArB_typerSrrrar~rgrrrrrrrrs& E>>>(WWW<QQQQ4   > = = =   &&&rrRouterMappingPairmappingrouter MethodPairr*calleec6eZdZdZdZdZdZdZdZdZ dS) MethodMappingaStores the mapping between caller and callee methods for a router. This class is primarily used in a ``get_metadata_routing()`` of a router object when defining the mapping between the router's methods and a sub-object (a sub-estimator or a scorer). Iterating through an instance of this class yields ``MethodPair(caller, callee)`` instances. .. versionadded:: 1.3 cg|_dSr.)_routesr=s rrSzMethodMapping.__init__s  rc*t|jSr.)iterrr=s r__iter__zMethodMapping.__iter__sDL!!!rc|tvrtd|dt|tvrtd|dt|jt |||S)adAdd a method mapping. Parameters ---------- caller : str Parent estimator's method name in which the ``callee`` is called. callee : str Child object's method name. This method is called in ``caller``. Returns ------- self : MethodMapping Returns self. z Given caller:z+ is not a valid method. Valid methods are: z Given callee:r*r)METHODSr%rappendr)r>r*rs rrzMethodMapping.adds"       JfVDDDEEE rczt}|jD]$}||j|jd%|S)zSerialize the object. Returns ------- obj : list A serialized version of the instance in the form of a list. r)listrrr*r)r>resultroutes rrzMethodMapping._serializesF\ L LE MMU\U\JJ K K K K rcDt|Sr.rr=s rrzMethodMapping.__repr__rrc:tt|Sr.rr=s rrzMethodMapping.__str__rrN) r$r@rArBrSrrrrrrrrrrsx  """<   &&&rrc^eZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdS)MetadataRouteraStores and handles metadata routing for a router object. This class is used by router objects to store and handle metadata routing. Routing information is stored as a dictionary of the form ``{"object_name": RouteMappingPair(method_mapping, routing_info)}``, where ``method_mapping`` is an instance of :class:`~sklearn.utils.metadata_routing.MethodMapping` and ``routing_info`` is either a :class:`~sklearn.utils.metadata_routing.MetadataRequest` or a :class:`~sklearn.utils.metadata_routing.MetadataRouter` instance. .. versionadded:: 1.3 Parameters ---------- owner : str The name of the object to which these requests belong. metadata_routercHt|_d|_||_dSr.)rP_route_mappings _self_requestr()r>r(s rrSzMetadataRouter.__init__s##vv " rct|dddkrt||_nFt|dr't||_nt d|S)a=Add `self` (as a consumer) to the routing. This method is used if the router is also a consumer, and hence the router itself needs to be included in the routing. The passed object can be an estimator or a :class:`~sklearn.utils.metadata_routing.MetadataRequest`. A router should add itself using this method instead of `add` since it should be treated differently than the other objects to which metadata is routed by the router. Parameters ---------- obj : object This is typically the router instance, i.e. `self` in a ``get_metadata_routing()`` implementation. It can also be a ``MetadataRequest`` instance. Returns ------- self : MetadataRouter Returns `self`. rNr_get_metadata_requestzGiven `obj` is neither a `MetadataRequest` nor does it implement the required API. Inheriting from `BaseEstimator` implements the required API.)rrrhasattrrr%)r>r6s radd_self_requestzMetadataRouter.add_self_request"s}0 3 & &*< < method_mappingobjsrr6s rrzMetadataRouter.addFs`"".11  ID#):&/Ec/J/J***D  & & rct}|jr||j||z}|jD]7\}}|jD]*\}}||kr||j||z}+8|S)r)r)r')r&rrrr3rr)r>r)r'r{_ route_mappingr*rs rrzMetadataRouter.consumes_s$ee   R*336&3QQQC $ 4 : : < <   A}"/"7  V## 4 = =%f!>!!C   rc Vt}|jr1|s/||j||}|jD]H\}}|jD];\}}||kr0||j|dd}r)r_rr{rrr*rs rrazMetadataRouter._get_param_names~s4ee   &9 ))"33! 4C $(#7#=#=#?#?   D-"/"7  V##))%,==#)RW>C  rct}|jr1||j||||||ddfd|D}t ||D]-}||||urtd|j d|d.|||S)aPrepare the given parameters to be passed to the method. This is used when a router is used as a child object of another router. The parent router then passes all parameters understood by the child object to it and delegates their validation to the child. The output of this method can be used directly as the input to the corresponding method as extra props. Parameters ---------- params : dict A dictionary of provided metadata. method : str The name of the method for which the parameters are requested and routed. parent : object Parent class object, that routes the metadata. caller : str Method from the parent class object, where the metadata is routed from. Returns ------- params : Bunch A :class:`~sklearn.utils.Bunch` of {prop: value} which can be given to the corresponding method. r'r)rxr*Trc$i|] \}}|v || Srr)r/r0r1 param_namess rr2z0MetadataRouter._route_params..s0   %33+;M;MC;M;M;MrzIn z, there is a conflict on z between what is requested for this estimator and what is requested by its children. You can resolve this conflict by using an alias for the child estimator(s) requested metadata.) r rrr~rar3r&r5 intersectionr%r() r>r'r)rxr*r{ child_paramsr0rs @rr~zMetadataRouter._route_paramssR>gg    JJ"00!!!! 1   ++$,      )/   sxxzz??// 0A0A0C0CDD  CC C00 B$*BBsBBB1 <    rcN|jr|j||t}|jD]Y\}}|j|j}}t||<|D]2\}} ||kr'||| |j|||| <3Z|S)aReturn the input parameters requested by child objects. The output of this method is a :class:`~sklearn.utils.Bunch`, which includes the metadata for all methods of each child object that is used in the router's `caller` method. If the router is also a consumer, it also checks for warnings of `self`'s/consumer's requested metadata. Parameters ---------- caller : str The name of the method for which the parameters are requested and routed. If called inside the :term:`fit` method of a router, it would be `"fit"`. params : dict A dictionary of provided metadata. Returns ------- params : Bunch A :class:`~sklearn.utils.Bunch` of the form ``{"object_name": {"method_name": {params: value}}}`` which can be used to pass the required metadata to corresponding methods or corresponding child objects. r'r)r) rrgr rr3rrr~r() r>r*r'r{rrrr_caller_callees r route_paramszMetadataRouter.route_paramss8   M   . .fV . L L Lgg#'#7#=#=#?#?   D-+2M4IGFCI$+   f$$)/)=)=%&#z% *>**CIg&  rc&||dd}|jr|j|d}nt}t||z |z }|rt |jd|d|ddS)aValidate given metadata for a method. This raises a ``TypeError`` if some of the passed metadata are not understood by child objects. Parameters ---------- method : str The name of the method for which the parameters are requested and routed. If called inside the :term:`fit` method of a router, it would be `"fit"`. params : dict A dictionary of provided metadata. Frrr"z got unexpected argument(s) z%, which are not routed to any object.N)rarr&r5 TypeErrorr()r>r)r'r self_params extra_keyss rvalidate_metadataz MetadataRouter.validate_metadatas ++5,     ,==E>KK%%K''+5 C  :1111J111   rcPt}|jr|j|d<|jD]Z\}}t||<|j||d<|j||d<[|S)r $self_requestrr)rPrrrr3rr)r>r{rrs rrzMetadataRouter._serialize6sff   C#'#5#@#@#B#BC #'#7#=#=#?#? D D D-CI#0#8#C#C#E#ECIi "/"6"A"A"C"CCIh   rc#K|jrIt}tD]}|||dt ||jfV|jD] \}}||fV dS)Nrrr)rrrrrrr3)r>rr)rrs rrzMetadataRouter.__iter__Hs   *__N! A A""&"@@@@!#4&t/A$$$   $(#7#=#=#?#? ( ( D-' ' ' ' ' ( (rcDt|Sr.rr=s rrzMetadataRouter.__repr__Srrc:tt|Sr.rr=s rrzMetadataRouter.__str__VrrN)r$r@rArBrrSrrrrar~rrrrrrrrrrrs* E"""H2>***X<<<|,,,\@$ ( ( (&&&rrct|dr!t|St|dddvrt|St dS)a]Get a ``Metadata{Router, Request}`` instance from the given object. This function returns a :class:`~sklearn.utils.metadata_routing.MetadataRouter` or a :class:`~sklearn.utils.metadata_routing.MetadataRequest` from the given input. This function always returns a copy or an instance constructed from the input, such that changing the output of this function will not change the original object. .. versionadded:: 1.3 Parameters ---------- obj : object - If the object provides a `get_metadata_routing` method, return a copy of the output of that method. - If the object is already a :class:`~sklearn.utils.metadata_routing.MetadataRequest` or a :class:`~sklearn.utils.metadata_routing.MetadataRouter`, return a copy of that. - Returns an empty :class:`~sklearn.utils.metadata_routing.MetadataRequest` otherwise. Returns ------- obj : MetadataRequest or MetadataRouting A ``MetadataRequest`` or a ``MetadataRouting`` taken or created from the given object. r?rN)rrr()rrr?rr)r6s rrrZsgBs*++0022333 gt $ $(O O O}}  & & &&ra Request metadata passed to the ``{method}`` method. Note that this method is only relevant if ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`). Please see :ref:`User Guide ` on how the routing mechanism works. The options for each parameter are: - ``True``: metadata is requested, and passed to ``{method}`` if provided. The request is ignored if metadata is not provided. - ``False``: metadata is not requested and the meta-estimator will not pass it to ``{method}``. - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it. - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name. The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the existing request. This allows you to change the request for some parameters and not others. .. versionadded:: 1.3 .. note:: This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect. Parameters ---------- z {metadata} : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED Metadata routing for ``{metadata}`` parameter in ``{method}``. zV Returns ------- self : object The updated object. c eZdZdZddZdZdS) RequestMethodas A descriptor for request methods. .. versionadded:: 1.3 Parameters ---------- name : str The name of the method for which the request function should be created, e.g. ``"fit"`` would create a ``set_fit_request`` function. keys : list of str A list of strings which are accepted parameters by the created function, e.g. ``["sample_weight"]`` if the corresponding method accepts it as a metadata. validate_keys : bool, default=True Whether to check if the requested parameters fit the actual parameters of the method. Notes ----- This class is a descriptor [1]_ and uses PEP-362 to set the signature of the returned function [2]_. References ---------- .. [1] https://docs.python.org/3/howto/descriptor.html .. [2] https://www.python.org/dev/peps/pep-0362/ Tc0||_||_||_dSr.)rr5 validate_keys)r>rr5rs rrSzRequestMethod.__init__s  *rcfd}djd|_tjdtjj|g}|djDtj|||_t j}jD]&}|t |j z }'|tz }||_ |S) Nc tstdjrut|tjz rQt dt|tjz djdtj|d}|dd}n}|r(t djd t|d |}t|j}| D]%\}}|tur| || &||_ |S) zUpdates the request for provided parameters This docstring is overwritten below. See REQUESTER_DOC for expected functionality zThis method is only available when metadata routing is enabled. You can enable it using sklearn.set_config(enable_metadata_routing=True).zUnexpected args: z in z. Accepted arguments are: Nrr set_z+_request() takes 0 positional argument but z were givenrYrZ)r RuntimeErrorrr&r5rrrrrr3 UNCHANGEDr[_metadata_request) rzkw _instancerRmethod_metadata_requestr^rZinstancer>s rfuncz#RequestMethod.__get__..funcs $%% "I ! s2wwTY'? @B#di..(@@@di@@/249~~@@ G ABBx$  /49//D /// !6688H&-h &B&B #!xxzz Q Q e ))+77d%7PPP*2I ' rr_requestr>)rkind annotationc g|]Q}tj|tjjttt t dtfRS)N)defaultr)inspect Parameter KEYWORD_ONLYrrrboolrF)r/ks rroz)RequestMethod.__get__..s^    !%2%'dD#o(>?    r)return_annotation)r))metadatar))rr$r r POSITIONAL_OR_KEYWORDextendr5 Signature __signature__ REQUESTER_DOCformatREQUESTER_DOC_PARAMREQUESTER_DOC_RETURNrB)r>rr(rr'docrs`` r__get__zRequestMethod.__get__s$, , , , , , `3ty222  &<             %. #   ""$)"44  S SH &--x -RR RCC ##  rN)T)r$r@rArBrSrrrrrrsG@++++ NNNNNrrceZdZdZerdZdZdZdZdZ dZ dZ d Z d Z d Zfd Zed ZedZdZdZxZS)_MetadataRequesterzMixin class for adding metadata request functionality. ``BaseEstimator`` inherits from this Mixin. .. versionadded:: 1.3 c dSr.rr>r7s rset_fit_requestz"_MetadataRequester.set_fit_requestCrc dSr.rrs rset_partial_fit_requestz*_MetadataRequester.set_partial_fit_requestDr rc dSr.rrs rset_predict_requestz&_MetadataRequester.set_predict_requestEr rc dSr.rrs rset_predict_proba_requestz,_MetadataRequester.set_predict_proba_requestFr rc dSr.rrs rset_predict_log_proba_requestz0_MetadataRequester.set_predict_log_proba_requestGr rc dSr.rrs rset_decision_function_requestz0_MetadataRequester.set_decision_function_requestHr rc dSr.rrs rset_score_requestz$_MetadataRequester.set_score_requestIr rc dSr.rrs rset_split_requestz$_MetadataRequester.set_split_requestJr rc dSr.rrs rset_transform_requestz(_MetadataRequester.set_transform_requestKr rc dSr.rrs rset_inverse_transform_requestz0_MetadataRequester.set_inverse_transform_requestLr rc  |}n*#t$rtjdi|YdSwxYwtD]n}t ||}t |js't|d|dt|t|j otjdi|dS)aSet the ``set_{method}_request`` methods. This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It looks for the information available in the set default values which are set using ``__metadata_request__*`` class attributes, or inferred from method signatures. The ``__metadata_request__*`` class attributes are used when a method does not explicitly accept a metadata through its arguments or if the developer would like to specify a request value for those metadata which are different from the default ``None``. References ---------- .. [1] https://www.python.org/dev/peps/pep-0487 Nrrr) _get_default_requests Exceptionsuper__init_subclass__rrrrRrrsortedr5)clsr7rRr)rr#s rr7z$_MetadataRequester.__init_subclass__Os" 0022HH    &EGG % / / / / / FF  %  F(F++Cs|$$  'v'''ffS\->->-@-@&A&ABB     "!++F+++++s #??ct|j|}t||r"tjt ||s|St tjt ||j dd}|D]7\}}|dvr |j |j |j hvr | |d8|S)aqBuild the `MethodMetadataRequest` for a method using its signature. This method takes all arguments from the method signature and uses ``None`` as their default request value, except ``X``, ``y``, ``Y``, ``Xt``, ``yt``, ``*args``, and ``**kwargs``. Parameters ---------- router : MetadataRequest The parent object for the created `MethodMetadataRequest`. method : str The name of the method. Returns ------- method_request : MethodMetadataRequest The prepared request using the method's signature. rr N>XYyXtytr)rNr$rr  isfunctionrr signature parametersr3rVAR_POSITIONAL VAR_KEYWORDr[)r9rr)rr'pnamerYs r_build_request_for_signaturez/_MetadataRequester._build_request_for_signatureus($#,vFFFsF## 7+=gc6>R>R+S+S Jg'V(<(<==HNNPPQQRSRTRTU"  LE5333ze2E4EFFF OO      rc  t|j}tD](}t|||||)d}t t j|D]}t| D]v\}}||vr || |t|zd}| D]*\}}t|| ||+w|S)zCollect default request values. This method combines the information present in ``__metadata_request__*`` class attributes, as well as determining request keys from method signatures. r)rr)__metadata_request__Nr)rr$rrrFreversedr getmrovarsr3indexrrr[) r9rRr)substr base_classattrr1r^rZs rr4z(_MetadataRequester._get_default_requestss:#666$  F 000PP    ("7>##6#677 S SJ#J//5577 S S e%%djj003v;;>@@A#(;;==SSKD% Hf--99E9RRRR S Srcxt|drt|j}n|}|S)a"Get requested data properties. Please check :ref:`User Guide ` on how the routing mechanism works. Returns ------- request : MetadataRequest A :class:`~sklearn.utils.metadata_routing.MetadataRequest` instance. r)rrrr4)r>rRs rrz(_MetadataRequester._get_metadata_requests? 4, - - 4-d.DEEHH1133Hrc*|S)aMGet metadata routing of this object. Please check :ref:`User Guide ` on how the routing mechanism works. Returns ------- routing : MetadataRequest A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating routing information. )rr=s rr?z'_MetadataRequester.get_metadata_routings))+++r)r$r@rArBrrr"r$r&r(r*r,r.r0r2r7 classmethodrFr4rr? __classcell__)r#s@rrr2s@ 211999555;;;??????333333777???$,$,$,$,$,L##[#J))[)V$ , , , , , , ,rrc |sGdd}|St|ds?t|ts*tdt |jjd|tvrtdtd|dt|}| || | || }|S) aValidate and route input parameters. This function is used inside a router's method, e.g. :term:`fit`, to validate the metadata and handle the routing. Assuming this signature of a router's fit method: ``fit(self, X, y, sample_weight=None, **fit_params)``, a call to this function would be: ``process_routing(self, "fit", sample_weight=sample_weight, **fit_params)``. Note that if routing is not enabled and ``kwargs`` is empty, then it returns an empty routing where ``process_routing(...).ANYTHING.ANY_METHOD`` is always an empty dictionary. .. versionadded:: 1.3 Parameters ---------- _obj : object An object implementing ``get_metadata_routing``. Typically a meta-estimator. _method : str The name of the router's method in which this function is called. **kwargs : dict Metadata to be routed. Returns ------- routed_params : Bunch A :class:`~utils.Bunch` of the form ``{"object_name": {"method_name": {params: value}}}`` which can be used to pass the required metadata to A :class:`~sklearn.utils.Bunch` of the form ``{"object_name": {"method_name": {params: value}}}`` which can be used to pass the required metadata to corresponding methods or corresponding child objects. The object names are those defined in `obj.get_metadata_routing()`. c"eZdZddZdZdZdS)%process_routing..EmptyRequestNc8tdidtDS)Nc,i|]}|tSrrPrns rr2z=process_routing..EmptyRequest.get..EEE6EEErrr r)r>rr s rrz)process_routing..EmptyRequest.get%FFEEWEEEFFFrc8tdidtDS)Nc,i|]}|tSrrYrns rr2zEprocess_routing..EmptyRequest.__getitem__.."rZrrr[r>rs r __getitem__z1process_routing..EmptyRequest.__getitem__!r\rc8tdidtDS)Nc,i|]}|tSrrYrns rr2zEprocess_routing..EmptyRequest.__getattr__..%rZrrr[r_s rrz1process_routing..EmptyRequest.__getattr__$r\rr.)r$r@rArr`rrrr EmptyRequestrVsR G G G G G G G G G G G Grrcr?zThe given object (zh) needs to either implement the routing method `get_metadata_routing` or be a `MetadataRouter` instance.z3Can only route and process input on these methods: z, while the passed method is: r"r)r'r*) rrErrrr#r$rrrrr)_obj_methodr7rcrequest_routingrus rprocess_routingrgs,N  G G G G G G G G|~~ D0 1 1 Zn5U5U  *dn&=!>!> * * *   g 6' 6 6+2 6 6 6   -T22O%%VG%DDD#00w0OOM rr.).rBr  collectionsrcopyrtypingrrrwarningsrrlr exceptionsr _bunchr rrvrr5rr r+r9r;rXrdrrDrJrLrNrrrrrrrrrrrrgrrrrns7JJ^""""""1111111111111111   "[)9% 44 1 6 6 8 899 9 > > >   D   :        4    tT648999. ( ( (,````````FllllllllpJ2Y4IJJZ x&: ; ; BBBBBBBBJVVVVVVVVr ''''''''b# H ttttttttns,s,s,s,s,s,s,s,@GGGGGr