
    {KgE                        d dl mZ d dlZd dlmZ d dlmZmZm	Z	m
Z
mZmZ d dlmZmZ d dlmZ d dlmZ d dlmZ d d	lmZmZmZ d d
lmZ d+dZ e       fdZ eed      Zd,dZ d Z! G d de"      Z# G d de
e      Z$ G d dee      Z% G d de
e      Z& G d dee      Z' G d dee      Z( G d de      Z) G d d e      Z* G d! d"ee      Z+ G d# d$e	e
e      Z, G d% d&e	e
e      Z- G d' d(e	ee      Z. G d) d*e	ee      Z/y)-    )partialN)assert_array_equal)BaseEstimatorClassifierMixinMetaEstimatorMixinRegressorMixinTransformerMixinclone)_Scorermean_squared_error)BaseCrossValidator)GroupsConsumerMixin)SIMPLE_METHODS)MetadataRouterMethodMappingprocess_routing)_check_partial_fit_first_callc                     t        | d      si | _        |s8|j                         D ci c]  \  }}t        |t              r|dk7  r|| }}}|| j                  |<   yc c}}w )zUtility function to store passed metadata to a method.

    If record_default is False, kwargs whose values are "default" are skipped.
    This is so that checks on keyword arguments whose default was not changed
    are skipped.

    _recordsdefaultN)hasattrr   items
isinstancestr)objmethodrecord_defaultkwargskeyvals         i/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/sklearn/tests/metadata_routing_common.pyrecord_metadatar"      sn     3
# #LLN
*Sc3'C9,< H* 	 

 "CLL
s   "Ac                    t        | dt                     j                  |t                     }t        |j	                               t        |j	                               k(  s)J d|j	                          d|j	                                 |j                         D ]o  \  }}||   }||v r)|'t        j                  ||      j                         r6J t        |t        j                        rt        ||       _||u rdJ d| d|         y)a  Check whether the expected metadata is passed to the object's method.

    Parameters
    ----------
    obj : estimator object
        sub-estimator to check routed params for
    method : str
        sub-estimator's method where metadata is routed to
    split_params : tuple, default=empty
        specifies any parameters which are to be checked as being a subset
        of the original values
    **kwargs : dict
        passed metadata
    r   z	Expected z vs N)getattrdictgetsetkeysr   npisinallr   ndarrayr   )r   r   split_paramsr   recordsr   valuerecorded_values           r!   check_recorded_metadatar1   /   s     c:tv.22646BGv{{}"  7	6;;=/glln%567  lln
U  ,>#=77>5155777."**5">59%.W)N;K4PUw0WW. %    F)r   c           	      X   t        | t              r0| D ]*  \  }}|
||v r||   }nd}t        |j                  |       , y|g n|}t        D ]U  }||v rt        | |      }|j                  j                         D cg c]  \  }}t        |t              s|| }	}}|	sUJ  yc c}}w )a  Check if a metadata request dict is empty.

    One can exclude a method or a list of methods from the check using the
    ``exclude`` parameter. If metadata_request is a MetadataRouter, then
    ``exclude`` can be of the form ``{"object" : [method, ...]}``.
    N)exclude)	r   r   assert_request_is_emptyrouterr   r$   requestsr   r   )
metadata_requestr4   nameroute_mapping_excluder   mmrpropaliaspropss
             r!   r5   r5   R   s     "N3#3D-"tw"4=#M$8$8(K $4 	ObG W&/  #||113
3e%%): 3 	 

 y !
s   >B&c                     |j                         D ]"  \  }}t        | |      }|j                  |k(  r"J  t        D cg c]	  }||vs| }}|D ]#  }t	        t        | |      j                        s#J  y c c}w N)r   r$   r7   r   len)request
dictionaryr   r7   r<   empty_methodss         r!   assert_request_equalrF   o   s    &,,.gv&||x''' / +9U.F*<TV.MUww/88999   Vs   	A7A7c                       e Zd Zd Zd Zy)	_Registryc                     | S rA    )selfmemos     r!   __deepcopy__z_Registry.__deepcopy__       r2   c                     | S rA   rJ   rK   s    r!   __copy__z_Registry.__copy__   rN   r2   N)__name__
__module____qualname__rM   rQ   rJ   r2   r!   rH   rH   y   s    r2   rH   c                   8    e Zd ZdZddZd	dZd	dZd
dZd	dZy)ConsumingRegressorac  A regressor consuming metadata.

    Parameters
    ----------
    registry : list, default=None
        If a list, the estimator will append itself to the list in order to have
        a reference to the estimator later on. Since that reference is not
        required in all tests, registration can be skipped by leaving this value
        as None.
    Nc                     || _         y rA   registryrK   rY   s     r!   __init__zConsumingRegressor.__init__   	     r2   c                 r    | j                   | j                   j                  |        t        | d||       | S Npartial_fitsample_weightmetadatarY   appendrecord_metadata_not_defaultrK   Xyra   rb   s        r!   r_   zConsumingRegressor.partial_fit   s6    ==$MM  &#-}x	
 r2   c                 r    | j                   | j                   j                  |        t        | d||       | S Nfitr`   rc   rf   s        r!   rk   zConsumingRegressor.fit   6    ==$MM  &#%}x	
 r2   c                 `    t        | d||       t        j                  t        |      f      S )Npredictr`   shape)re   r)   zerosrB   rf   s        r!   rn   zConsumingRegressor.predict   s*    #)=8	
 xxs1vi((r2   c                 "    t        | d||       y)Nscorer`      )re   rf   s        r!   rs   zConsumingRegressor.score   s    #'	
 r2   rA   r   r   Nr   r   )	rR   rS   rT   __doc__r[   r_   rk   rn   rs   rJ   r2   r!   rV   rV      s     	!)r2   rV   c                   2    e Zd ZdZddZd Zd	dZd Zd Zy)
NonConsumingClassifier5A classifier which accepts no metadata on any method.c                     || _         y rA   )alpha)rK   r|   s     r!   r[   zNonConsumingClassifier.__init__   s	    
r2   c                 :    t        j                  |      | _        | S rA   )r)   uniqueclasses_rK   rg   rh   s      r!   rk   zNonConsumingClassifier.fit   s    		!r2   Nc                     | S rA   rJ   )rK   rg   rh   classess       r!   r_   z"NonConsumingClassifier.partial_fit   rN   r2   c                 $    | j                  |      S rA   )rn   rK   rg   s     r!   decision_functionz(NonConsumingClassifier.decision_function   s    ||Ar2   c                     t        j                  t        |      f      }d|d t        |      dz   d|t        |      dz  d  |S )Nro   r      rt   )r)   emptyrB   )rK   rg   y_preds      r!   rn   zNonConsumingClassifier.predict   sC    Q	* !}Q1 !s1v{}r2   )        rA   )	rR   rS   rT   rw   r[   rk   r_   r   rn   rJ   r2   r!   ry   ry      s    ?r2   ry   c                   "    e Zd ZdZd Zd Zd Zy)NonConsumingRegressorrz   c                     | S rA   rJ   r   s      r!   rk   zNonConsumingRegressor.fit   rN   r2   c                     | S rA   rJ   r   s      r!   r_   z!NonConsumingRegressor.partial_fit   rN   r2   c                 >    t        j                  t        |            S rA   )r)   onesrB   r   s     r!   rn   zNonConsumingRegressor.predict   s    wws1vr2   N)rR   rS   rT   rw   rk   r_   rn   rJ   r2   r!   r   r      s    ?r2   r   c                   J    e Zd ZdZd
dZ	 ddZddZddZddZddZ	dd	Z
y)ConsumingClassifiera  A classifier consuming metadata.

    Parameters
    ----------
    registry : list, default=None
        If a list, the estimator will append itself to the list in order to have
        a reference to the estimator later on. Since that reference is not
        required in all tests, registration can be skipped by leaving this value
        as None.

    alpha : float, default=0
        This parameter is only used to test the ``*SearchCV`` objects, and
        doesn't do anything.
    Nc                      || _         || _        y rA   )r|   rY   )rK   rY   r|   s      r!   r[   zConsumingClassifier.__init__   s    
 r2   c                     | j                   | j                   j                  |        t        | d||       t        | |       | S r^   )rY   rd   re   r   )rK   rg   rh   r   ra   rb   s         r!   r_   zConsumingClassifier.partial_fit   sB     ==$MM  &#-}x	
 	&dG4r2   c                     | j                   | j                   j                  |        t        | d||       t        j                  |      | _        | S rj   )rY   rd   re   r)   r~   r   rf   s        r!   rk   zConsumingClassifier.fit   sE    ==$MM  &#%}x	
 		!r2   c                     t        | d||       t        j                  t        |      fd      }d|t        |      dz  d  d|d t        |      dz   |S )Nrn   r`   int8)rp   dtyper   r   rt   re   r)   r   rB   rK   rg   ra   rb   y_scores        r!   rn   zConsumingClassifier.predict  sX    #)=8	
 ((#a&&9!"A!!"#a&A+r2   c                    t        | d||       t        j                  t        |      df      }t        j                  ddg      |d t        |      dz  d d f<   t        j                  ddg      |t        |      dz  d d d f<   |S )Npredict_probar`   r   ro   g      ?r   )re   r)   r   rB   asarray)rK   rg   ra   rb   y_probas        r!   r   z!ConsumingClassifier.predict_proba  s~    #/	
 ((#a&!-$&JJSz$:#a&A+q !$&JJSz$:A!q !r2   c                      y rA   rJ   rK   rg   ra   rb   s       r!   predict_log_probaz%ConsumingClassifier.predict_log_proba  s    r2   c                     t        | d||       t        j                  t        |      f      }d|t        |      dz  d  d|d t        |      dz   |S )Nr   r`   ro   r   r   rt   r   r   s        r!   r   z%ConsumingClassifier.decision_function  sV    #/	
 ((#a&+!"A!!"#a&A+r2   )Nr   rv   ru   )rR   rS   rT   rw   r[   r_   rk   rn   r   r   r   rJ   r2   r!   r   r      s1    !
 EN
	r2   r   c                   8    e Zd ZdZddZd	dZd
dZd
dZd
dZy)ConsumingTransformera~  A transformer which accepts metadata on fit and transform.

    Parameters
    ----------
    registry : list, default=None
        If a list, the estimator will append itself to the list in order to have
        a reference to the estimator later on. Since that reference is not
        required in all tests, registration can be skipped by leaving this value
        as None.
    Nc                     || _         y rA   rX   rZ   s     r!   r[   zConsumingTransformer.__init__;  r\   r2   c                 r    | j                   | j                   j                  |        t        | d||       | S rj   rc   rf   s        r!   rk   zConsumingTransformer.fit>  rl   r2   c                 $    t        | d||       |S N	transformr`   r"   r   s       r!   r   zConsumingTransformer.transformG      +]X	
 r2   c                 n    t        | d||       | j                  ||||      j                  |||      S )Nfit_transformr`   )r"   rk   r   rf   s        r!   r   z"ConsumingTransformer.fit_transformM  sH    
 	/	
 xx1MHxMWW]X X 
 	
r2   c                 $    t        | d||       |S )Ninverse_transformr`   r   r   s       r!   r   z&ConsumingTransformer.inverse_transformY  s    %]X	
 r2   rA   NNNNN)	rR   rS   rT   rw   r[   rk   r   r   r   rJ   r2   r!   r   r   /  s     	!

r2   r   c                   (    e Zd ZdZddZddZddZy)	"ConsumingNoFitTransformTransformerzA metadata consuming transformer that doesn't inherit from
    TransformerMixin, and thus doesn't implement `fit_transform`. Note that
    TransformerMixin's `fit_transform` doesn't route metadata to `transform`.Nc                     || _         y rA   rX   rZ   s     r!   r[   z+ConsumingNoFitTransformTransformer.__init__e  r\   r2   c                 r    | j                   | j                   j                  |        t        | d||       | S rj   )rY   rd   r"   rf   s        r!   rk   z&ConsumingNoFitTransformTransformer.fith  s1    ==$MM  &e=8Tr2   c                 $    t        | d||       |S r   r   r   s       r!   r   z,ConsumingNoFitTransformTransformer.transformp  r   r2   rA   r   r   )rR   rS   rT   rw   r[   rk   r   rJ   r2   r!   r   r   `  s    Q!r2   r   c                   *     e Zd Zd fd	Z fdZ xZS )ConsumingScorerc                 B    t         |   t        di d       || _        y )Nrt   rn   )
score_funcsignr   response_method)superr[   r   rY   )rK   rY   	__class__s     r!   r[   zConsumingScorer.__init__x  s'    )"i 	 	
 !r2   c                     | j                   | j                   j                  |        t        | dfi | |j                  dd       }t        |   |||||      S )Nrs   ra   ra   )rY   rd   re   r&   r   _score)rK   method_callerclfrg   rh   r   ra   r   s          r!   r   zConsumingScorer._score~  sW    ==$MM  &#D'<V<

?D9w~mS!Qm~TTr2   rA   )rR   rS   rT   r[   r   __classcell__)r   s   @r!   r   r   w  s    !U Ur2   r   c                   ,    e Zd ZddZddZddZd	dZy)
ConsumingSplitterNc                     || _         y rA   rX   rZ   s     r!   r[   zConsumingSplitter.__init__  r\   r2   c              #     K   | j                   | j                   j                  |        t        | d||       t        |      dz  }t	        t        d|            }t	        t        |t        |                  }||f ||f y w)Nsplit)groupsrb   r   r   )rY   rd   re   rB   listrange)rK   rg   rh   r   rb   split_indextrain_indicestest_indicess           r!   r   zConsumingSplitter.split  sy     ==$MM  &#D'&8T!fkU1k23E+s1v67M))\))s   BBc                      y)Nr   rJ   )rK   rg   rh   r   rb   s        r!   get_n_splitszConsumingSplitter.get_n_splits  s    r2   c              #      K   t        |      dz  }t        t        d|            }t        t        |t        |                  }| | y w)Nr   r   )rB   r   r   )rK   rg   rh   r   r   r   r   s          r!   _iter_test_indicesz$ConsumingSplitter._iter_test_indices  sE     !fkU1k23E+s1v67s   AArA   rv   )NNNNr   )rR   rS   rT   r[   r   r   r   rJ   r2   r!   r   r     s    !
*r2   r   c                   "    e Zd ZdZd Zd Zd Zy)MetaRegressorz(A meta-regressor which is only a router.c                     || _         y rA   )	estimator)rK   r   s     r!   r[   zMetaRegressor.__init__  s	    "r2   c                     t        | dfi |} t        | j                        j                  ||fi |j                  j                  | _        y Nrk   )r   r
   r   rk   
estimator_rK   rg   rh   
fit_paramsparamss        r!   rk   zMetaRegressor.fit  sC     u;
;3%/33AqQF<L<L<P<PQr2   c                     t        | j                  j                        j                  | j                  t               j                  dd            }|S Nownerrk   callercalleer   method_mapping)r   r   rR   addr   r   rK   r6   s     r!   get_metadata_routingz"MetaRegressor.get_metadata_routing  sJ    dnn&=&=>BBnn(?..eE.J C 
 r2   NrR   rS   rT   rw   r[   rk   r   rJ   r2   r!   r   r     s    2#Rr2   r   c                   ,    e Zd ZdZddZddZd Zd Zy)WeightedMetaRegressorz*A meta-regressor which is also a consumer.Nc                      || _         || _        y rA   r   rY   rK   r   rY   s      r!   r[   zWeightedMetaRegressor.__init__      " r2   c                    | j                   | j                   j                  |        t        | d|       t        | dfd|i|} t	        | j
                        j                  ||fi |j
                  j                  | _        | S Nrk   r   ra   rY   rd   r"   r   r
   r   rk   r   )rK   rg   rh   ra   r   r   s         r!   rk   zWeightedMetaRegressor.fit  su    ==$MM  &e=A uXMXZX3%/33AqQF<L<L<P<PQr2   c                 ~    t        | dfi |} | j                  j                  |fi |j                  j                  S )Nrn   )r   r   rn   r   )rK   rg   predict_paramsr   s       r!   rn   zWeightedMetaRegressor.predict  s;     yCNC&t&&qEF,<,<,D,DEEr2   c                     t        | j                  j                        j                  |       j	                  | j
                  t               j	                  dd      j	                  dd            }|S )Nr   rk   r   rn   r   r   r   rR   add_self_requestr   r   r   r   s     r!   r   z*WeightedMetaRegressor.get_metadata_routing  sb    !8!89d#S..,E%0Ii8	   	 r2   rA   )rR   rS   rT   rw   r[   rk   rn   r   rJ   r2   r!   r   r     s    4!Fr2   r   c                   &    e Zd ZdZddZddZd Zy)WeightedMetaClassifierzEA meta-estimator which also consumes sample_weight itself in ``fit``.Nc                      || _         || _        y rA   r   r   s      r!   r[   zWeightedMetaClassifier.__init__  r   r2   c                    | j                   | j                   j                  |        t        | d|       t        | dfd|i|} t	        | j
                        j                  ||fi |j
                  j                  | _        | S r   r   )rK   rg   rh   ra   r   r   s         r!   rk   zWeightedMetaClassifier.fit  su    ==$MM  &e=A uTMTVT3%/33AqQF<L<L<P<PQr2   c                     t        | j                  j                        j                  |       j	                  | j
                  t               j	                  dd            }|S r   r   r   s     r!   r   z+WeightedMetaClassifier.get_metadata_routing  sV    !8!89d#S..,22%2N   	 r2   rA   r   rJ   r2   r!   r   r     s    O!	r2   r   c                   ,    e Zd ZdZd ZddZddZd Zy)MetaTransformerzA simple meta-transformer.c                     || _         y rA   )transformer)rK   r  s     r!   r[   zMetaTransformer.__init__  s
    &r2   Nc                     t        | dfi |} t        | j                        j                  ||fi |j                  j                  | _        | S r   )r   r
   r  rk   transformer_r   s        r!   rk   zMetaTransformer.fit  sK     u;
;7E$"2"23771W@R@R@V@VWr2   c                 ~    t        | dfi |} | j                  j                  |fi |j                  j                  S )Nr   )r   r  r   r  )rK   rg   rh   transform_paramsr   s        r!   r   zMetaTransformer.transform  s>     {G6FG*t  **1M0B0B0L0LMMr2   c                     t        | j                  j                        j                  | j                  t               j                  dd      j                  dd            S )Nr   rk   r   r   )r  r   )r   r   rR   r   r  r   rP   s    r!   r   z$MetaTransformer.get_metadata_routing  sT    DNN$;$;<@@(((?SeS,SKS8	 A 
 	
r2   rA   )rR   rS   rT   rw   r[   rk   r   r   rJ   r2   r!   r   r     s    $'
N
r2   r   )TrA   )0	functoolsr   numpyr)   numpy.testingr   sklearn.baser   r   r   r   r	   r
   sklearn.metrics._scorerr   r   sklearn.model_selectionr   sklearn.model_selection._splitr    sklearn.utils._metadata_requestsr   sklearn.utils.metadata_routingr   r   r   sklearn.utils.multiclassr   r"   tupler1   re   r5   rF   r   rH   rV   ry   r   r   r   r   r   r   r   r   r   r   rJ   r2   r!   <module>r     s-     ,  @ 6 > 
 C"& 7<g X@ &oeL ::
 
+ +\_m .
NM 
M/= Mn.+] .b .Ug U"+-? 6& $. D/- 8
(*:M 
r2   