U 9%eL @s@dZddlZddlmZddlmZddlmZmZddl m Z ddl m Z dd l mZd d lmZd d ddddddddg ZddZdZdZdZdddeegZddZdd ZGd!d"d"ZGd#d$d$Zed%d&d'gZed(d)d*gZGd+d,d,ZGd-d.d.Zd:d/d0Zd1Z d2Z!d3Z"Gd4d5d5Z#Gd6d7d7Z$d8d9Z%dS);a 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``, 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 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)OptionalUnion)warn) get_config)UnsetMetadataPassedError)BunchfitZ partial_fitZpredictZ predict_probaZpredict_log_probaZdecision_functionZscoresplitZ transformZinverse_transformcCstddS)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. Zenable_metadata_routingF)rgetrr_/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sklearn/utils/_metadata_requests.py_routing_enabledjs rz$UNUSED$z$WARN$z $UNCHANGED$FTcCs|tkr dSt|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 isidentifieritemrrrrequest_is_aliassrcCs|tkS)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. )rrrrrrequest_is_valids rc@s\eZdZdZddZeddZddZdd Zd d Z d d Z ddZ ddZ ddZ dS)MethodMetadataRequestabA 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. cCst|_||_||_dSN)dict _requestsownermethodselfrrrrr__init__szMethodMetadataRequest.__init__cCs|jS)z)Dictionary of the form: ``{key: alias}``.rr!rrrrequestsszMethodMetadataRequest.requestscCsnt|s&t|s&td|d|d||kr2d}|tkr`||jkrN|j|=qjtd|dn ||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.)rr ValueErrorUNUSEDr)r!paramaliasrrr add_requests    z!MethodMetadataRequest.add_requestcstfdd|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. c3s6|].\}}t|r|dk rr*t|s*|n|VqdS)FN)r.0propr* return_aliasrr sz9MethodMetadataRequest._get_param_names..)setritems)r!r0rr/r_get_param_namess z&MethodMetadataRequest._get_param_namescsFdkr infdd|jD}|D]}td|dq,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. Ncs$h|]\}}|tkr|kr|qSr)WARNr,paramsrr 'sz8MethodMetadataRequest._check_warnings..z Support for z has recently been added to this class. To maintain backward compatibility, it is ignored now. You can set the request value to False to silence this warning, or to True to consume and use the metadata.)rr3r)r!r7Z warn_paramsr)rr6r_check_warningss   z%MethodMetadataRequest._check_warningscCs|j|dt}dd|D}t}|jD]l\}}|dks4|tkrPq4q4|dkrn||krn||||<q4|dkr||kr||||<q4||kr4||||<q4|rtddd d |Dd |jd |j ||d |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. Returns ------- params : Bunch A :class:`~utils.Bunch` of {prop: value} which can be given to the corresponding method. r6cSsi|]\}}|dk r||qSrr)r-argvaluerrr Gsz7MethodMetadataRequest._route_params..FTN[z, cSsg|]}|qSrr)r-keyrrr Usz7MethodMetadataRequest._route_params..z@] are passed but are not explicitly set as requested or not for .)messageZunrequested_params routed_params) r9rr3r rr5r joinrr)r!r7Z unrequestedargsresr.r*rrr _route_params4s( ( z#MethodMetadataRequest._route_paramscCs|jSSerialize the object. Returns ------- obj : dict A serialized version of the instance in the form of a dictionary. r#r$rrr _serialize^sz MethodMetadataRequest._serializecCs t|SrrrIr$rrr__repr__hszMethodMetadataRequest.__repr__cCs tt|Srrreprr$rrr__str__kszMethodMetadataRequest.__str__N)__name__ __module__ __qualname____doc__r"propertyr%r+r4r9rFrIrKrNrrrrrs 0* rc@sNeZdZdZdZddZdddZdd Zd d Zd d Z ddZ ddZ 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_requestcCs"tD]}t||t||dqdS)Nrr)METHODSsetattrrr rrrr"s  zMetadataRequest.__init__NcCst||j|dS)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/)getattrr4)r!rr0ignore_self_requestrrrr4sz MetadataRequest._get_param_namescCst||j|dS)adPrepare 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 ---------- method : str The name of the method for which the parameters are requested and routed. params : dict A dictionary of provided metadata. Returns ------- params : Bunch A :class:`~utils.Bunch` of {prop: value} which can be given to the corresponding method. r6)rYrFr!rr7rrrrFszMetadataRequest._route_paramscCst||j|ddS)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. r6N)rYr9r[rrrr9s zMetadataRequest._check_warningscCs4t}tD]$}t||}t|jr |||<q |SrG)rrWrYlenr%rI)r!outputrmmrrrrrIs   zMetadataRequest._serializecCs t|SrrJr$rrrrKszMetadataRequest.__repr__cCs tt|SrrLr$rrrrNszMetadataRequest.__str__)N) rOrPrQrR_typer"r4rFr9rIrKrNrrrrrTos rTRouterMappingPairmappingrouter MethodPaircalleecallerc@sLeZdZdZddZddZddZdd Zed d Z d d Z ddZ dS) MethodMappingaStores the mapping between callee and caller methods for a router. This class is primarily used in a ``get_metadata_routing()`` of a router object when defining the mapping between a sub-object (a sub-estimator or a scorer) to the router's methods. It stores a collection of ``Route`` namedtuples. Iterating through an instance of this class will yield named ``MethodPair(callee, caller)`` tuples. .. versionadded:: 1.3 cCs g|_dSr)_routesr$rrrr"szMethodMapping.__init__cCs t|jSr)iterrgr$rrr__iter__szMethodMapping.__iter__cCsP|tkrtd|dt|tkr8td|dt|jt||d|S)acAdd a method mapping. Parameters ---------- callee : str Child object's method name. This method is called in ``caller``. caller : str Parent estimator's method name in which the ``callee`` is called. Returns ------- self : MethodMapping Returns self. z Given callee:z+ is not a valid method. Valid methods are: z Given caller:rdre)rWr'rgappendrc)r!rdrerrraddszMethodMapping.addcCs*t}|jD]}||j|jdq |S)zSerialize the object. Returns ------- obj : list A serialized version of the instance in the form of a list. rj)listrgrkrdre)r!resultrouterrrrI#s zMethodMapping._serializecCsL|}|dkr(tD]}|j||dqn |tkr@|j||dntd|S)aConstruct an instance from a string. Parameters ---------- route : str A string representing the mapping, it can be: - `"one-to-one"`: a one to one mapping for all methods. - `"method"`: the name of a single method, such as ``fit``, ``transform``, ``score``, etc. Returns ------- obj : MethodMapping A :class:`~sklearn.utils.metadata_routing.MethodMapping` instance constructed from the given string. one-to-onerjz0route should be 'one-to-one' or a single method!)rWrlr')clsroZroutingrrrrfrom_str0szMethodMapping.from_strcCs t|SrrJr$rrrrKMszMethodMapping.__repr__cCs tt|SrrLr$rrrrNPszMethodMapping.__str__N) rOrPrQrRr"rirlrI classmethodrrrKrNrrrrrfs   rfc@sleZdZdZdZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZdS)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:`~utils.metadata_routing.MetadataRequest` or a :class:`~utils.metadata_routing.MetadataRouter` instance. .. versionadded:: 1.3 Parameters ---------- owner : str The name of the object to which these requests belong. metadata_routercCst|_d|_||_dSr)r_route_mappings _self_requestr)r!rrrrr"lszMetadataRouter.__init__cCsBt|dddkrt||_n"t|dr6t||_ntd|S)a5Add `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:`~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`. r_NrU_get_metadata_requestzGiven `obj` is neither a `MetadataRequest` nor does it implement the required API. Inheriting from `BaseEstimator` implements the required API.)rYrrwhasattrrxr')r!objrrradd_self_requestus  zMetadataRouter.add_self_requestcKsJt|trt|}nt|}|D]\}}t|t|d|j|<q&|S)ahAdd named objects with their corresponding method mapping. Parameters ---------- method_mapping : MethodMapping or str The mapping between the child and the parent's methods. If str, the output of :func:`~sklearn.utils.metadata_routing.MethodMapping.from_str` is used. **objs : dict A dictionary of objects from which metadata is extracted by calling :func:`~sklearn.utils.metadata_routing.get_routing_for_object` on them. Returns ------- self : MetadataRouter Returns `self`. rarb) rrrfrrrr3r`get_routing_for_objectrv)r!Zmethod_mappingZobjsnamerzrrrrls  zMetadataRouter.addc Csnt}|jr&|s&||jj||d}|jD]8\}}|jD](\}}||kr>||jj|ddd}q>q0|S)a`Get 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 parameters. rr0TFrr0rZ)r2rwunionr4rvr3rarb) r!rr0rZrEr~ route_mappingrdrerrrr4s& zMetadataRouter._get_param_namescst}|jr"||jj||d|j|dddfdd|D}t||D],}||||k r^t d|j d|dq^|||S) a/Prepare 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 ---------- method : str The name of the method for which the parameters are requested and routed. params : dict A dictionary of provided metadata. Returns ------- params : Bunch A :class:`~sklearn.utils.Bunch` of {prop: value} which can be given to the corresponding method. r7rTrcsi|]\}}|kr||qSrr)r-r>r; param_namesrrr<sz0MetadataRouter._route_params..zIn 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 rwupdaterFr4r3r2keys intersectionr'r)r!r7rrEZ child_paramsr>rrrrFs$  zMetadataRouter._route_paramsc Csx|jr|jj||dt}|jD]L\}}|j|j}}t||<|D]&\}} | |krJ|j||d|||<qJq&|S)aReturn the input parameters requested by child objects. The output of this method is a bunch, which includes the inputs for all methods of each child object that are 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:`~utils.Bunch` of the form ``{"object_name": {"method_name": {prop: value}}}`` which can be used to pass the required metadata to corresponding methods or corresponding child objects. r)rwr9r rvr3rbrarF) r!rer7rEr~rrbraZ_calleeZ_callerrrr route_paramss  zMetadataRouter.route_paramscCs^|j|ddd}|jr(|jj|dd}nt}t|||}|rZt|d|ddS)aValidate given metadata for a method. This raises a ``ValueError`` 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. Frrz got unexpected argument(s) z1, which are not requested metadata in any object.N)r4rwr2r TypeError)r!rr7rZ self_paramsZ extra_keysrrrvalidate_metadata?s z MetadataRouter.validate_metadatacCs`t}|jr|j|d<|jD]6\}}t||<|j||d<|j||d<q$|S)rH $self_requestrarb)rrwrIrvr3rarb)r!rEr~rrrrrI_s zMetadataRouter._serializeccsB|jr dttd|jdfV|jD]\}}||fVq*dS)Nrrpr|)rwr`rfrrrvr3)r!r~rrrrriqs zMetadataRouter.__iter__cCs t|SrrJr$rrrrKyszMetadataRouter.__repr__cCs tt|SrrLr$rrrrN|szMetadataRouter.__str__N)rOrPrQrRr_r"r{rlr4rFrrrIrirKrNrrrrrtTs $,1+ rtcCs8t|drt|St|dddkr.t|StddS)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 is already a :class:`~sklearn.utils.metadata_routing.MetadataRequest` or a :class:`~sklearn.utils.metadata_routing.MetadataRouter`, return a copy of that. - If the object provides a `get_metadata_routing` method, return a copy of the output of that method. - 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. get_metadata_routingr_N)rUrur)ryrrrYrT)rzrrrr}s !  r}a 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@s"eZdZdZdddZddZdS) 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/ TcCs||_||_||_dSr)r~r validate_keys)r!r~rrrrrr"szRequestMethod.__init__csfdd}djd|_tjdtjj|dg}|ddjDtj||d |_t j jd }jD]}|t j |jd 7}qn|t 7}||_ |S) NcststdjrNt|tjrNtdt|tjdtj}t|j}| D]\}}|t k rj|j ||dqj|_ 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. Accepted arguments are: r)r*) r RuntimeErrorrr2rrrxrYr~r3 UNCHANGEDr+_metadata_request)kwr%Zmethod_metadata_requestr.r*instancer!rrfunc s" z#RequestMethod.__get__..funcset__requestr!)r~kind annotationc Ss0g|](}tj|tjjttttdtfdqS)N)defaultr)inspect Parameter KEYWORD_ONLYrrrboolr)r-krrrr?1sz)RequestMethod.__get__..)return_annotation)r)metadatar)r~rOrrPOSITIONAL_OR_KEYWORDextendr Signature __signature__ REQUESTER_DOCformatREQUESTER_DOC_PARAMREQUESTER_DOC_RETURNrR)r!rrrr7docrrrr__get__s.  zRequestMethod.__get__N)T)rOrPrQrRr"rrrrrrs rcsHeZdZdZfddZeddZeddZdd Zd d Z Z S) _MetadataRequesterzMixin class for adding metadata request functionality. ``BaseEstimator`` inherits from this Mixin. .. versionadded:: 1.3 c sz |}Wn$tk r0tjf|YdSXtD]>}t||}t|jsPq6t|d|dt |t |j q6tjf|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 Nrr) _get_default_requests Exceptionsuper__init_subclass__rWrYr\r%rXrsortedr)rqkwargsr%rr^ __class__rrrOs    z$_MetadataRequester.__init_subclass__cCst|j|d}t||r(tt||s,|Sttt||j dd}|D]4\}}|dkrdqR|j |j |j hkrxqR|j |ddqR|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. rVr N>YyXytXtr)rrOryr isfunctionrYrm signature parametersr3rVAR_POSITIONAL VAR_KEYWORDr+)rqrbrr^r7Zpnamer)rrr_build_request_for_signatureus" z/_MetadataRequester._build_request_for_signaturec Cst|jd}tD]}t|||j||dqt}tt|D]$}ddt | D}| |q@tt | }| D]L\}}d}|| |t|d}| D]\} } t||j| | dqq~|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)rbrcSsi|]\}}d|kr||qS)__metadata_request__r)r-attrr;rrrr<sz<_MetadataRequester._get_default_requests..rNr)rTrOrWrXrrreversedrgetmrovarsr3rrindexr\rYr+) rqr%rdefaultsZ base_classZ base_defaultsrr;substrr.r*rrrrs(    z(_MetadataRequester._get_default_requestscCs"t|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)ryr}rr)r!r%rrrrxs  z(_MetadataRequester._get_metadata_requestcCs|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. )rxr$rrrrs z'_MetadataRequester.get_metadata_routing) rOrPrQrRrrsrrrxr __classcell__rrrrrGs & % -rcKst|ds"tdt|jjd|tkr@tdtd|d|dk rL|nt}||t |}|j ||d|j ||d }|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: ``fit(self, X, y, sample_weight=None, **fit_params)``, a call to this function would be: ``process_routing(self, fit_params, sample_weight=sample_weight)``. .. 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. other_params : dict A dictionary of extra parameters passed to the router's method, e.g. ``**fit_params`` passed to a meta-estimator's :term:`fit`. **kwargs : dict Parameters explicitly accepted and included in the router's method signature. Returns ------- routed_params : Bunch A :class:`~utils.Bunch` of the form ``{"object_name": {"method_name": {prop: 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()`. rzThis z? has not implemented the routing method `get_metadata_routing`.z3Can only route and process input on these methods: z, while the passed method is: r@Nr)r7re) ryAttributeErrorrMrrOrWrrrr}rr)rzrZ other_paramsr all_paramsZrequest_routingrBrrrprocess_routings%   r)N)&rRr collectionsrcopyrtypingrrwarningsrr exceptionsr Z_bunchr rWrr(r5rrrrrrTr`rcrfrtr}rrrrrrrrrrsVO      5|b. 1$f*