-iSrSSKrSSKJr SSKJr SSKJrJrJ r SSK J r SSK J r SS KJr S S KJr /S QrS S/S S/S.r\\"\R+55-rSrS4SjrSr"SS5rSrSrSrSSS\\/rSrSr "SS5r!"SS 5r"\"S!S"S#/5r#\"S$S%S&/5r$"S'S(5r%"S)S*5r&S4S+jr'S,r(S-r)S.r*"S/S05r+"S1S25r,S3r-g)5a 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. The routing is coordinated by building ``MetadataRequest`` objects for objects that consume metadata, and ``MetadataRouter`` objects for objects that can route metadata, which are then aligned during a call to `process_routing()`. This function returns a Bunch object (dictionary-like) with all the information on the consumers and which metadata they had requested and the actual metadata values. A routing method (such as `fit` in a meta-estimator) can now provide the metadata to the relevant consuming method (such as `fit` in a sub-estimator). The ``MetadataRequest`` and ``MetadataRouter`` objects are constructed via a ``get_metadata_routing`` method, which all scikit-learn estimators provide. This method is automatically implemented via ``BaseEstimator`` for all simple estimators, but needs a custom implementation for meta-estimators. MetadataRequest ~~~~~~~~~~~~~~~ In non-routing consumers, the simplest case, e.g. ``SVM``, ``get_metadata_routing`` returns a ``MetadataRequest`` object which is assigned to the consumer's `_metadata_request` attribute. It stores which metadata is required by each method of the consumer by including one ``MethodMetadataRequest`` per method in ``METHODS`` (e. g. ``fit``, ``score``, etc). Users and developers almost never need to directly add a new ``MethodMetadataRequest``, to the consumer's `_metadata_request` attribute, since these are generated automatically. This attribute is modified while running `set_{method}_request` methods (such as `set_fit_request()`), which adds the request via `method_metadata_request.add_request(param=prop, alias=alias)`. The ``alias`` in the ``add_request`` method has to be either a string (an alias), or one of ``[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 ~~~~~~~~~~~~~~ In routers (such as meta-estimators or multi metric scorers), ``get_metadata_routing`` returns a ``MetadataRouter`` object. It provides information about which method, from the router object, calls which method in a consumer's object, and also, which metadata had been requested by the consumer's methods, thus specifying how metadata is to be passed. If a sub-estimator is a router as well, their routing information is also stored in the meta-estimators router. Conceptually, this information looks like: ``` { "sub_estimator1": ( mapping=[(caller="fit", callee="transform"), ...], router=MetadataRequest(...), # or another MetadataRouter ), ... } ``` The `MetadataRouter` objects are never stored and are always recreated anew whenever the object's `get_metadata_routing` method is called. An object that is both a router and a consumer, e.g. a meta-estimator which consumes ``sample_weight`` and routes ``sample_weight`` to its sub-estimators also returns a ``MetadataRouter`` object. Its routing information includes both information about what metadata is required by the object itself (added via ``MetadataRouter.add_self_request``), as well as the routing information for its sub-estimators (added via ``MetadataRouter.add``). Implementation Details ~~~~~~~~~~~~~~~~~~~~~~ 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 ``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_predictc6[5RSS5$)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 getS/var/www/html/venv/lib/python3.13/site-packages/sklearn/utils/_metadata_requests.py_routing_enabledr s <  5u ==rcU(aURRSU3OURRnUbUO0n[5(d3UR5U- (a[ SUS[ U535egg)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". allow : list of str, default=None A list of parameters which are allowed to be passed even if metadata routing is not enabled. Raises ------ ValueError If metadata routing is not enabled and params are passed. .Nz#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: ) __class____name__r keys ValueErrorset)paramsownermethodallowcallers r_raise_for_paramsr-s4395?? # # $AfX.eoo>V>V &EBE   6;;=5#81&:67:&k]  D  $9 rc UR5VVs0sH up4UcM X4_M nnn[5(aLU(aDURRn[ USUS[ UR 55SUS35eggs snnf)a5Raise 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. Nr"z cannot accept given metadata (z4) since metadata routing is not yet implemented for )itemsr r#r$NotImplementedErrorr'r%)objr*kwargskeyvaluecls_names r_raise_for_unsupported_routingr6s(,2<<> O>ZSUjcj>F Of==))!j&!@V[[]AS@TUBBJ1 N  %Ps BBc\rSrSrSrSrSrg)_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. cF[URRS35e)zSRaise `NotImplementedError`. This estimator does not support metadata routing yet.z* has not implemented metadata routing yet.)r0r#r$selfs rget_metadata_routing._RoutingNotSupportedMixin.get_metadata_routings'"~~&&''Q R  rrN)r$ __module__ __qualname____firstlineno____doc__r=__static_attributes__rrrr8r8s  rr8z$UNUSED$z$WARN$z $UNCHANGED$FTcfU[;ag[U[5=(a UR5$)aqCheck if an item is a valid string alias for a metadata. 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 for the metadata. Returns ------- result : bool Whether the given item is a valid alias. F)VALID_REQUEST_VALUES isinstancestr isidentifieritems rrequest_is_aliasrK s-  ## dC 8T%6%6%88rcU[;$)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. )rErIs rrequest_is_validrM s ' ''rcb\rSrSrSrSSjr\S5rSrSr Sr S r S r S r S rS rSrg)MethodMetadataRequesti6aContainer for metadata requests associated with a single method. Instances of this class get used within a :class:`MetadataRequest` - one per each public method (`fit`, `transform`, ...) that its owning consumer has. .. 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. NcLU=(d [5UlXlX lgN)dict _requestsr)r*)r<r)r*requestss r__init__MethodMetadataRequest.__init__Js!+TV  rcUR$)z)Dictionary of the form: ``{key: alias}``.rSr;s rrTMethodMetadataRequest.requestsOs~~rc[U5(d"[U5(d[SUSUS35eX!:XaSnU[:Xa-XR;aURU U$[SUS35eX RU'U$)aAdd request info for a metadata. Parameters ---------- param : str The metadata for which a request is set. alias : str, or {True, False, None} Specifies which metadata should be routed to the method that owns this `MethodMetadataRequest`. - str: the name (or alias) of metadata given to a meta-estimator that should be routed to the method that owns this `MethodMetadataRequest`. - 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.)rKrMr&UNUSEDrS)r<paramaliass r add_request!MethodMetadataRequest.add_requestTs4 &&/?/F/F08#WA'  >E F?&NN5) !1%9 %*NN5 ! rc^^[U4SjURR555$)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 metadata. c3># UH9up[U5(aUSLdMT(a[U5(dUOUv M; g7f)FN)rM).0propr^ return_aliass r 9MethodMetadataRequest._get_param_names..sA 5 #E**e5.@ L\*:5*A*AEt K5s A"A)r'rSr/)r<res `r_get_param_names&MethodMetadataRequest._get_param_namess," #~~335   rc Uc0OUnURR5VVs1sHup#U[:XdMX!;dMUiM nnnUH"n[SUSURSUS35 M$ gs snnf)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. Nz 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.)rSr/WARNrr*)r<r(rdr^ warn_paramsr]s r_check_warnings%MethodMetadataRequest._check_warningss~6 $~~335 5 } !% 5  !E ug&"kk])E7;$$ !  sA2A2A2c  URUS9 [5nUR5VVs0sH upVUcM XV_M nnn[5nURR5HEupU SLd U [ :XaMU SLa X;aXyX'M(U c X;aXyXI'M8X;dM?XzX'MG U(aUR [;a[UR n O UR /n SRU V s/sH n SU S3PM sn 5n SSRUVs/sHoPM sn5S URS UR S US US UR3 U -S -n[UUUS9eU$s snnfs sn fs snf)aPrepare the given metadata to be passed to the method. The output of this method can be used directly as the input to the corresponding method as **kwargs. 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 {metadata: value} which can be passed to the corresponding method. r(FTz.set_z_request({metadata}=True/False)[, zJ] 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. See the Metadata Routing User guide for more information.)messageunrequested_params routed_params) rmrRr/r rSrkr*COMPOSITE_METHODSjoinr)r )r<r(parentr, unrequestedargr4argsresrdr^callee_methodsr*set_requests_onr3rts r _route_params#MethodMetadataRequest._route_paramss. F+f -3\\^Q^zsu  ^Qg>>//1KD~$$4< J 4<$(J ! K 2 {{//!24;;!?"&++ gg#1"0F8#DE"0ODIIk:kssk:;<=JJ>//1KD} E3''EO 2  rcUR$xSerialize the object. Returns ------- obj : dict A serialized version of the instance in the form of a dictionary. rXr;s r _serialize MethodMetadataRequest._serialize s~~rc4[UR55$rQrGrr;s r__repr__MethodMetadataRequest.__repr__4??$%%rc*[[U55$rQrGreprr;s r__str__MethodMetadataRequest.__str__4:r)rSr*r)rQ)r$r?r@rArBrUpropertyrTr_rhrmrrrrrrCrrrrOrO6sJ& /b .4?B,&rrOcV\rSrSrSrSrSrSrSrSSjr S r S r S r S r S rSrg)MetadataRequestiaContains 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 RXl[Hn[UU[XS95 M g)Nr)r*)r)SIMPLE_METHODSsetattrrO)r<r)r*s rrUMetadataRequest.__init__4s' $F %EA %rc2[X5RUS9$)aLCheck whether the given metadata 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. rp)getattrrr<r*r(s rconsumesMetadataRequest.consumes=s$t$..f.==rc XU[;a&[SURRSUS35e0n[UHn[ X5n[ UR 55n[ URR 55nXV-nUVs/sHoUURU:wdMUPM n nU (a:[SSRU 5SUSSR[U5S35eURUR5 M [URXS9$s snf) N'z' object has no attribute 'z"Conflicting metadata requests for rsz" while composing the requests for z*. Metadata with the same name for methods z$ should have the same request value.)r)r*rT)rwAttributeErrorr#r$rr'r%rTrSr&rxupdaterOr)) r<namerTr*mmrexistingupcomingcommonr3 conflictss r __getattr__MetadataRequest.__getattr__Qs* ( ( DNN++,,GvQO '-F$'C8==?+H3<<,,./H(F(.V3-3==QTCU2UIV 899M8NO337&9$$(II.?.E$F#GH++ OOCMM *.%4::dVVWs D'+D'Nc2[X5RUS9$)aJGet 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 metadata. )re)rrh)r<r*reignore_self_requests rrh MetadataRequest._get_param_namesos0t$55<5PPrc4[X5RXUS9$)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 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 {metadata: value} which can be given to the corresponding method. )r(ryr,)rr)r<r(r*ryr,s rrMetadataRequest._route_paramss&6t$223  rc4[X5RUS9 g)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. rpN)rrmrs rrmMetadataRequest._check_warningss --V- U$r)rRrrlenrTr)r<outputr*rs rrMetadataRequest._serializesC$F$'C3<<  !$!1% rc4[UR55$rQrr;s rrMetadataRequest.__repr__rrc*[[U55$rQrr;s rrMetadataRequest.__str__rrr)rQ)r$r?r@rArB_typerUrrrhrrmrrrrCrrrrrs=& E>(W<Q4 > = &rrRouterMappingPairmappingrouter MethodPairr,calleec<\rSrSrSrSrSrSrSrSr Sr S r g ) MethodMappingiaxStores the mapping between caller and callee methods for a :term:`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 c/UlgrQ_routesr;s rrUMethodMapping.__init__s  rc,[UR5$rQ)iterrr;s r__iter__MethodMapping.__iter__sDLL!!rcU[;a[SUS[35eU[;a[SUS[35eURR[ XS95 U$)a Add 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 rrMethodMapping.addsz"  x(9   x(9  JfDE rc[5nURH+nURURURS.5 M- U$)zrSerialize the object. Returns ------- obj : list A serialized version of the instance in the form of a list. r)listrrr,r)r<resultroutes rrMethodMapping._serializes7\\E MMU\\U\\J K" rc4[UR55$rQrr;s rrMethodMapping.__repr__rrc*[[U55$rQrr;s rrMethodMapping.__str__rrrN) r$r?r@rArBrUrrrrrrCrrrrrs% "< &rrcd\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrg)MetadataRouteri"aCoordinates metadata routing for a :term:`router` object. This class is used by :term:`meta-estimators` or functions that can route metadata, to handle their metadata routing. Routing information is stored in a dictionary-like structure of the form ``{"object_name": RouterMappingPair(mapping, router)}``, where ``mapping`` is an instance of :class:`~sklearn.utils.metadata_routing.MethodMapping` and ``router`` is either a :class:`~sklearn.utils.metadata_routing.MetadataRequest` or another :class:`~sklearn.utils.metadata_routing.MetadataRouter` instance. .. versionadded:: 1.3 Parameters ---------- owner : str The name of the object to which these requests belong. metadata_routerc<[5UlSUlXlgrQ)rR_route_mappings _self_requestr))r<r)s rrUMetadataRouter.__init__;s#v " rc[USS5S:Xa[U5UlU$[US5(a [UR 55UlU$[ S5e)aAdd `self` (as a :term:`consumer`) to the `MetadataRouter`. This method is used if the :term:`router` is also a :term:`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 consumer 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<r1s radd_self_requestMetadataRouter.add_self_requestDsj0 3 &*< ` to the `MetadataRouter`. The estimators that consume metadata are passed as named objects along with a method mapping, that defines how their methods relate to those of the :term:`router`. Parameters ---------- method_mapping : MethodMapping The mapping between the child (:term:`consumer`) and the parent's (:term:`router`'s) methods. **objs : dict A dictionary of objects, whose requests are extracted by calling :func:`~sklearn.utils.metadata_routing.get_routing_for_object` on them. Returns ------- self : MetadataRouter Returns `self`. rr)rr/rget_routing_for_objectr)r<method_mappingobjsrr1s rrMetadataRouter.addhsG,".1ID):&/Ec/J*D  && rc&[5nUR(aX0RRXS9-nURR 5H<upEUR H'upgXa:XdM X5R RXrS9-nM) M> U$)aKCheck whether the given metadata is 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. )r*r()r'rrrr/rr)r<r*r(r}_ route_mappingr,rs rrMetadataRouter.consumess$e   **3363QQC $ 4 4 : : < A"/"7"7# 4 4 = =%!>!C#8!= rc l[5nUR(a/U(d(URURRXS95nURR 5HKupVUR H6upxXq:XdM URURRUSSS95nM8 MM U$)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, which only applies to the stored `self`. If no `self` routing object is stored, this parameter has no effect. ignore_self_request : bool If `self._self_request` should be ignored. This is used in `_route_params`. If ``True``, ``return_alias`` has no effect. Returns ------- names : set of str A set of strings with the names of all metadata. r*reTFr*rer)r'runionrhrr/rr) r<r*rerr}rrr,rs rrhMetadataRouter._get_param_namess4e   &9))""33!4C $(#7#7#=#=#? D"/"7"7#))%,,==#)RW>C#8$@ rc [5nUR(a+URURRUUUUS95 UR USSS9nUR 5VVs0sHupxXv;dM Xx_M n nn[ UR55RU R55H(nXXWLdM[SURSUS35e URU 5 U$s snnf)a5Prepare the given metadata 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 **kwargs. Parameters ---------- params : dict A dictionary of provided metadata. method : str The name of the method for which the metadata is 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 {metadata: value} which can be given to the corresponding method. r(r*ryr,TrzIn 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 estimators' requested metadata.) r rrrrhr/r'r% intersectionr&r)) r<r(r*ryr,r} param_namesr3r4 child_paramss rrMetadataRouter._route_paramss<g    JJ""00!!!! 1 ++$, *0 )7:33;MJCJ  sxxz?// 0A0A0CDC 0 $**%>seDAA E <   s + C8:C8c `UR(aURRX!S9 [5nURR 5H[upEUR UR pv[5X4'UH-upX:XdM URUU URUS9X4U 'M/ M] U$)aGet the values of metadata requested by :term:`consumers `. Returns a :class:`~sklearn.utils.Bunch` containing the metadata that this :term:`router`'s `caller` method needs to route, organized by each :term:`consumer` and their corresponding methods. This can be used to pass the required metadata to corresponding methods in consumers. Parameters ---------- caller : str The name of the :term:`router`'s method through which the metadata is routed. For example, if called inside the :term:`fit` method of a router, this 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": {metadata: value}}}``. r(r*r) rrmr rr/rrrr)) r<r,r(r}rrrr_caller_callees r route_paramsMetadataRouter.route_paramss4       . .f . Lg#'#7#7#=#=#? D+22M4I4IGCI$+ $)/)=)=%&#zz% *>*CIg&%, $@ rcURUSSS9nUR(aURRUSS9nO [5n[UR55U- U- nU(a[ UR SUSUS35eg)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 :term:`router`'s method through which the metadata is routed. For example, if called inside the :term:`fit` method of a router, this 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)rhrr'r% TypeErrorr))r<r*r(r self_params extra_keyss rvalidate_metadata MetadataRouter.validate_metadata:s ++5,    ,,==E>K%K'+5 C ::,ax'CJ<P11  rcP[5nUR(aURR5US'URR 5HOup#[5X'UR R5XS'UR R5XS'MQ U$)r $self_requestrr)rRrrrr/rr)r<r}rrs rrMetadataRouter._serializeZsf   #'#5#5#@#@#BC #'#7#7#=#=#? DCI#0#8#8#C#C#ECIi "/"6"6"A"A"CCIh $@  rc## UR(a=[5n[HnURX"S9 M S[ XRS94v UR R 5H up4X44v M g7f)Nrr r)rrrrrrr/)r<rr*rrs rrMetadataRouter.__iter__lsu   *_N!""&"@" !.ASAST $(#7#7#=#=#? D' '$@sA8A:c4[UR55$rQrr;s rrMetadataRouter.__repr__xrrc*[[U55$rQrr;s rrMetadataRouter.__str__{rr)rrr)N)r$r?r@rArBrrUrrrrhrrr rrrrrCrrrrr"sO, E"H<>*X;z*X@$ (&rrc[US5(a[UR55$[USS5S;a [U5$[ SS9$)aGet 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 MetadataRouter A ``MetadataRequest`` or a ``MetadataRouter`` taken or created from the given object. r=rN)rrr)rrr=rr)r1s rrrsNBs*++00233 gt $(O O}  &&ra Configure whether metadata should be requested to be passed to the ``{method}`` method. Note that this method is only relevant when this estimator is used as a sub-estimator within a :term:`meta-estimator` and metadata routing is enabled with ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`). Please check the :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 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(\rSrSrSrSSjrSrSrg) RequestMethodia; Descriptor for defining `set_{method}_request` methods in estimators. .. 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/ c(XlX lX0lgrQ)rr% validate_keys)r<rr%rs rrURequestMethod.__init__s  *rc^^UU4SjnSTRS3Ul[R"S[RRUS9/nUR TR Vs/sHOn[R"U[RR[[[[S[4S9PMQ sn5 [R"UUS9Ul[R!TRS9nTR H$nU["R!UTRS 9- nM& U[$- nXclU$s snf) Nc >[5(d [S5eTR(av[U5[TR5- (aP[ S[U5[TR5- STR S[TR535eTc USnUSSnOTnU(a%[ STR S [U5S 35eUR5n[UTR 5nUR5HupVU[LdMURXVS 9 M! X2l U$) zUpdates the `_metadata_request` attribute of the consumer (`instance`) for the parameters provided as `**kw`. 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 givenr]r^)r RuntimeErrorrr'r%rrrrrr/ UNCHANGEDr__metadata_request) r|kw _instancerTmethod_metadata_requestrdr^instancer<s rfunc#RequestMethod.__get__..funcs6$%%"I !!s2wTYY'?'B#dii.(@'Adii[Q//2499~.>@ G ABx$ 499+&D {+/ !668H&-h &B #!xxz  )+77d7P *+3 ' rr_requestr<)rkind annotation)defaultr))return_annotation)r*)metadatar*)rr$inspect ParameterPOSITIONAL_OR_KEYWORDextendr% KEYWORD_ONLYrrrboolrG Signature __signature__ REQUESTER_DOCformatREQUESTER_DOC_PARAMREQUESTER_DOC_RETURNrB)r<r$r)r%r(kdocr,s`` r__get__RequestMethod.__get__s*- btyyk2   &&<<      #A !!%%22%'dD#o(>?  #  %.. # ""$))"4 H &--x -R RC" ##  ' s'AE)r%rrN)T)r$r?r@rArBrUr;rCrrrrrs@+ Orrc^\rSrSrSr\(aSrSrSrSr Sr Sr S r S r S rS rU4S jr\S5r\S5rSrSrSrU=r$)_MetadataRequesteriUz{Mixin class for adding metadata request functionality. ``BaseEstimator`` inherits from this Mixin. .. versionadded:: 1.3 c grQrr<r2s rset_fit_request"_MetadataRequester.set_fit_requestfsTrc grQrr@s rset_partial_fit_request*_MetadataRequester.set_partial_fit_requestgsTrc grQrr@s rset_predict_request&_MetadataRequester.set_predict_requesthsrc grQrr@s rset_predict_proba_request,_MetadataRequester.set_predict_proba_requestistrc grQrr@s rset_predict_log_proba_request0_MetadataRequester.set_predict_log_proba_requestj4rc grQrr@s rset_decision_function_request0_MetadataRequester.set_decision_function_requestkrOrc grQrr@s rset_score_request$_MetadataRequester.set_score_requestltrc grQrr@s rset_split_request$_MetadataRequester.set_split_requestmrVrc grQrr@s rset_transform_request(_MetadataRequester.set_transform_requestns4rc grQrr@s rset_inverse_transform_request0_MetadataRequester.set_inverse_transform_requestorOrc h>UR5n[Hfn[ X#5n[ UR5(dM*[USUS3[U[URR5555 Mh [TU] "S0UD6 g![a [TU] "S0UD6 gf=f)aZSet 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 Nrr'r) _get_default_requests Exceptionsuper__init_subclass__rrrrTrrsortedr%)clsr2rTr*rr#s rrd$_MetadataRequester.__init_subclass__rs" 002H%F(+Cs||$$ vhh'ffS\\->->-@&AB  % !+F+#  G % / /   sBB10B1c[URUS9n[X5(a$[R"[ X55(dU$[ [R"[ X55RR55SSnUHEupVUS;aM URURUR1;aM5URUSS9 MG U$)aBuild 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)rOr$rr- isfunctionrr signature parametersr/r(VAR_POSITIONAL VAR_KEYWORDr_)rfrr*rr(pnamer]s r_build_request_for_signature/_MetadataRequester._build_request_for_signatures($#,,vFs##7+=+=gc>R+S+SJg''(<=HHNNPQRSRTU"LE33zze22E4E4EFF OO   # rc [URS9n[Hn[UUUR XS95 M Sn[ [ R"U55H|n[U5R5H\upVX5;aM XURU5[U5-SnUR5Hupx[X5RXxS9 M M^ M~ U$)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$rrrtreversedr-getmrovarsr/indexrrr_) rfrTr*substr base_classattrr4rdr^s rra(_MetadataRequester._get_default_requestss#6$F 000P % ("7>>##67J#J/557 %jj03v;>@A#(;;=KD H-999R $1 88rcv[US5(a[UR5nU$UR5nU$)zGet requested metadata for the instance. Please check :ref:`User Guide ` on how the routing mechanism works. Returns ------- request : MetadataRequest A :class:`~sklearn.utils.metadata_routing.MetadataRequest` instance. r )rrr ra)r<rTs rr(_MetadataRequester._get_metadata_requests> 4, - --d.D.DEH113Hrc"UR5$)a Get 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='_MetadataRequester.get_metadata_routings))++rr)r$r?r@rArBrrArDrGrJrMrQrTrXr[r^rd classmethodrtrarr=rC __classcell__)r#s@rr>r>Usl 295;??337?$,L##J))V$ , ,rr>c \U(d"SS5nU"5$[US5(d9[U[5(d$[SURR <S35eU[ ;a[S[ SUS35e[U5nURX!S 9 URX!S 9nU$) aValidate and route metadata. This function is used inside a :term:`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 :term:`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": {metadata: value}}}`` which can be used to pass the required metadata to A :class:`~sklearn.utils.Bunch` of the form ``{"object_name": {"method_name": {metadata: 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*\rSrSrSSjrSrSrSrg)%process_routing..EmptyRequesti@Nc \[S0[Vs0sH o3[5_M snD6$s snfNrr rrR)r<rr*r*s rr)process_routing..EmptyRequest.getA&FWEW6WEFFE) c \[S0[Vs0sH o"[5_M snD6$s snfrrr<rr*s r __getitem__1process_routing..EmptyRequest.__getitem__Drrc \[S0[Vs0sH o"[5_M snD6$s snfrrrs rr1process_routing..EmptyRequest.__getattr__GrrrrQ)r$r?r@rArrrrCrrr EmptyRequestr@s G G Grrr=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,) rrFrrr#r$rrrr r)_obj_methodr2rrequest_routingrvs rprocess_routingrsN  G G~ D0 1 1Zn5U5U !8!8 ;<* *  gA'K++2)1 6  -T2O%%V%D#000OM rrQ).rBr- collectionsrcopyrtypingrrrwarningsrrqr exceptionsr _bunchr rrwrr%rr r-r6r8r\rkrrErKrMrOrrrrrrr5r7r8rr>rrrrrsI_H"111 "[)9% 4 1 6 6 89 9 >& R :  4    tT6489. (,eePllp2Y4IJ x&: ; BBJZZz ''b  B uups,s,@Gr