
    Pi                        d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlmZm	Z	 d dl
Z
d dlZd dlmZ d dlmZmZ d dlmZmZmZmZ d dlmZ d dlmZmZ d dlmZ d d	lm Z m!Z!m"Z" d d
l#m$Z$m%Z%m&Z&m'Z' d dl(m)Z) d dl*m+Z+ d dl,m-Z- d dl.m/Z/m0Z0 d dl1m2Z2m3Z3m4Z4 d dl5m6Z6m7Z7 d dl8m9Z9m:Z: d dl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZA d dlBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZk d dllmmZmmnZn d dlompZp d dlqmrZr d dlsmtZtmuZumvZvmwZw d Zx G d dey          Zz G d dee          Z{ G d de          Z| G d d e          Z} G d! d"e          Z~ G d# d$e          Z G d% d&e          Z G d' d(e          Z G d) d*e          Z G d+ d,e          Z G d- d.e          Z G d/ d0e{          Z G d1 d2e{          Z G d3 d4e{          Z G d5 d6e          Z G d7 d8e{          Z G d9 d:e          Z G d; d<e          Z G d= d>e          Z G d? d@e{          Z G dA dBe          Z G dC dDee          Z G dE dFe          Z G dG dHe'          Z G dI dJe          Z G dK dLe$          Z G dM dNe$          Z G dO dPe%          Z G dQ dRe          Z G dS dTe          ZdU ZdV ZdW ZdX ZdY ZexdZ             Zd[ Zd\ Zd] Zd^ Zd_ Zd` Zda Zdb Zdc Zdd Zexde             Zdf Zdg Zdh Zdi Zdj Zdk Zexdl             Zdm Zdn Zdo Z G dp dqee          Zdr Zds Zdt Zdu Zdv Zexdw             Zedxk    r
 e             dy Zdz Zexd{             Zexd|             Zd} Zd~ Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zexd             Zd Zd Zd Zd ZdS )    N)isgenerator)IntegralReal)config_context
get_config)BaseEstimatorClassifierMixinOutlierMixinTransformerMixin)MiniBatchKMeans)	load_irismake_multilabel_classification)PCA)ConvergenceWarningEstimatorCheckFailedWarningSkipTestWarning)LinearRegressionLogisticRegressionMultiTaskElasticNetSGDClassifier)GaussianMixture)KNeighborsRegressor)StandardScaler)SVCNuSVC)
_array_apiall_estimators
deprecated)Interval
StrOptions)_construct_instances_get_expected_failed_checks)MinimalClassifierMinimalRegressorMinimalTransformerSkipTestignore_warningsraises))_check_name_NotAnArray_yield_all_checkscheck_array_api_input-check_class_weight_balanced_linear_classifier"check_classifier_data_not_an_array*check_classifier_not_supporting_multiclass<check_classifiers_multilabel_output_format_decision_function2check_classifiers_multilabel_output_format_predict8check_classifiers_multilabel_output_format_predict_proba*check_classifiers_one_label_sample_weights(check_dataframe_column_names_consistency check_decision_proba_consistencycheck_dict_unchangedcheck_dont_overwrite_parameterscheck_estimatorcheck_estimator_cloneablecheck_estimator_reprcheck_estimator_sparse_arraycheck_estimator_sparse_matrixcheck_estimator_sparse_tagcheck_estimator_tags_renamedcheck_estimators_nan_inf!check_estimators_overwrite_paramscheck_estimators_unfittedcheck_fit_check_is_fittedcheck_fit_score_takes_y%check_methods_sample_order_invariancecheck_methods_subset_invariancecheck_mixin_ordercheck_no_attributes_set_in_initcheck_outlier_contaminationcheck_outlier_corruption&check_parameters_default_constructible"check_positive_only_tag_during_fit!check_regressor_data_not_an_arraycheck_requires_y_none"check_sample_weights_pandas_seriescheck_set_paramsestimator_checks_generatorset_random_state)CSR_CONTAINERSSPARRAY_PRESENT)available_if)type_of_target)check_arraycheck_is_fitted	check_X_yvalidate_datac                 |    t           j                            d          }||j                            |           S | S )Npytest)sysmodulesgetmarkthread_unsafe)fr[   s     }/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/sklearn/utils/tests/test_estimator_checks.py&_mark_thread_unsafe_if_pytest_importedrc   l   s6    [__X&&F{((+++    c                       e Zd ZdZdS )CorrectNotFittedErrorzException class to raise if estimator is used before fitting.

    Like NotFittedError, it inherits from ValueError, but not from
    AttributeError. Used for testing only.
    N)__name__
__module____qualname____doc__ rd   rb   rf   rf   t   s           rd   rf   c                       e Zd Zd Zd ZdS )BaseBadClassifierc                     | S Nrk   selfXys      rb   fitzBaseBadClassifier.fit}       rd   c                 @    t          j        |j        d                   S Nr   nponesshaperq   rr   s     rb   predictzBaseBadClassifier.predict   s    wqwqz"""rd   Nrg   rh   ri   rt   r}   rk   rd   rb   rm   rm   |   s2          # # # # #rd   rm   c                   $    e Zd ZddZddZd ZdS )ChangesDictr   c                     || _         d S ro   )key)rq   r   s     rb   __init__zChangesDict.__init__   s    rd   Nc                 .    t          | ||          \  }}| S ro   rY   rp   s      rb   rt   zChangesDict.fit       T1a((1rd   c                 l    t          |          }d| _        t          j        |j        d                   S )Ni  r   )rV   r   ry   rz   r{   r|   s     rb   r}   zChangesDict.predict   s*    NNwqwqz"""rd   r   ro   rg   rh   ri   r   rt   r}   rk   rd   rb   r   r      sK              # # # # #rd   r   c                       e Zd ZddZddZdS )SetsWrongAttributer   c                     || _         d S ro   )acceptable_key)rq   r   s     rb   r   zSetsWrongAttribute.__init__   s    ,rd   Nc                 <    d| _         t          | ||          \  }}| S rw   wrong_attributerY   rp   s      rb   rt   zSetsWrongAttribute.fit   $     T1a((1rd   r   ro   rg   rh   ri   r   rt   rk   rd   rb   r   r      s<        - - - -     rd   r   c                       e Zd ZddZddZdS )ChangesWrongAttributer   c                     || _         d S ro   )r   )rq   r   s     rb   r   zChangesWrongAttribute.__init__       .rd   Nc                 <    d| _         t          | ||          \  }}| S N   r   rp   s      rb   rt   zChangesWrongAttribute.fit   r   rd   r   ro   r   rk   rd   rb   r   r      s<        / / / /     rd   r   c                       e Zd ZddZdS )ChangesUnderscoreAttributeNc                 <    d| _         t          | ||          \  }}| S r   )_good_attributerY   rp   s      rb   rt   zChangesUnderscoreAttribute.fit   r   rd   ro   rg   rh   ri   rt   rk   rd   rb   r   r      s(             rd   r   c                   .     e Zd ZddZ fdZddZ xZS )RaisesErrorInSetParamsr   c                     || _         d S ro   prq   r   s     rb   r   zRaisesErrorInSetParams.__init__       rd   c                     d|v r1|                     d          }|dk     rt          d          || _         t                      j        di |S )Nr   r   zp can't be less than 0rk   )pop
ValueErrorr   super
set_paramsrq   kwargsr   	__class__s      rb   r   z!RaisesErrorInSetParams.set_params   sW    &==

3A1uu !9:::DF!uww!++F+++rd   Nc                 .    t          | ||          \  }}| S ro   r   rp   s      rb   rt   zRaisesErrorInSetParams.fit   r   rd   r   ro   rg   rh   ri   r   r   rt   __classcell__r   s   @rb   r   r      `           , , , , ,       rd   r   c                   0    e Zd Z e            fdZddZdS )HasMutableParametersc                     || _         d S ro   r   r   s     rb   r   zHasMutableParameters.__init__   r   rd   Nc                 .    t          | ||          \  }}| S ro   r   rp   s      rb   rt   zHasMutableParameters.fit   r   rd   ro   )rg   rh   ri   objectr   rt   rk   rd   rb   r   r      sE                 rd   r   c                   @    e Zd Zd ej        d          efdZddZdS )HasImmutableParameters*   c                 0    || _         || _        || _        d S ro   )r   qr)rq   r   r   r   s       rb   r   zHasImmutableParameters.__init__   s    rd   Nc                 .    t          | ||          \  }}| S ro   r   rp   s      rb   rt   zHasImmutableParameters.fit   r   rd   ro   )rg   rh   ri   ry   int32r   r   rt   rk   rd   rb   r   r      sM        xrx||v    
     rd   r   c                   .     e Zd ZddZ fdZddZ xZS )"ModifiesValueInsteadOfRaisingErrorr   c                     || _         d S ro   r   r   s     rb   r   z+ModifiesValueInsteadOfRaisingError.__init__   r   rd   c                     d|v r$|                     d          }|dk     rd}|| _         t                      j        di |S )Nr   r   rk   )r   r   r   r   r   s      rb   r   z-ModifiesValueInsteadOfRaisingError.set_params   sM    &==

3A1uuDF!uww!++F+++rd   Nc                 .    t          | ||          \  }}| S ro   r   rp   s      rb   rt   z&ModifiesValueInsteadOfRaisingError.fit   r   rd   r   ro   r   r   s   @rb   r   r      r   rd   r   c                   .     e Zd ZddZ fdZddZ xZS )	ModifiesAnotherValuer   method1c                 "    || _         || _        d S ro   )ab)rq   r   r   s      rb   r   zModifiesAnotherValue.__init__   s    rd   c                     d|v r:|                     d          }|| _        ||                     d           d| _         t                      j        di |S )Nr   r   method2rk   )r   r   r   r   r   )rq   r   r   r   s      rb   r   zModifiesAnotherValue.set_params   sZ    &==

3ADFy

3"!uww!++F+++rd   Nc                 .    t          | ||          \  }}| S ro   r   rp   s      rb   rt   zModifiesAnotherValue.fit   r   rd   )r   r   ro   r   r   s   @rb   r   r      s`           , , , , ,       rd   r   c                       e Zd Zd ZdS )NoCheckinPredictc                 .    t          | ||          \  }}| S ro   r   rp   s      rb   rt   zNoCheckinPredict.fit   r   rd   Nr   rk   rd   rb   r   r      s#            rd   r   c                   "    e Zd ZddZd Zd ZdS )NoSparseClassifierNc                     || _         d S ro   raise_for_typerq   r   s     rb   r   zNoSparseClassifier.__init__       ,rd   c                     t          | ||ddg          \  }}| j        dk    rt          |t          j                  }n%| j        dk    rt          |t          j                  }|rt          d          | S )Ncsrcscaccept_sparsesparse_arraysparse_matrixNonsensical Error)rY   r   
isinstancespsparrayspmatrixr   rq   rr   rs   correct_types       rb   rt   zNoSparseClassifier.fit  s|    T1au~FFF1.00%a44LL O33%a55L 	20111rd   c                 ^    t          |          }t          j        |j        d                   S rw   rV   ry   rz   r{   r|   s     rb   r}   zNoSparseClassifier.predict  #    NNwqwqz"""rd   ro   r   rk   rd   rb   r   r      sF        - - - -  # # # # #rd   r   c                       e Zd Zd Zd ZdS )CorrectNotFittedErrorClassifierc                 v    t          | ||          \  }}t          j        |j        d                   | _        | S r   )rY   ry   rz   r{   coef_rp   s      rb   rt   z#CorrectNotFittedErrorClassifier.fit  s3    T1a((1WQWQZ((
rd   c                 |    t          |            t          |          }t          j        |j        d                   S rw   )rW   rV   ry   rz   r{   r|   s     rb   r}   z'CorrectNotFittedErrorClassifier.predict  s1    NNwqwqz"""rd   Nr~   rk   rd   rb   r   r     s2          
# # # # #rd   r   c                       e Zd ZddZd ZdS )NoSampleWeightPandasSeriesTypeNc                     t          | ||ddd          \  }}ddlm} t          ||          rt	          d          | S )Nr   r   Tr   multi_output	y_numericr   Seriesz>Estimator does not accept 'sample_weight'of type pandas.Series)rY   pandasr   r   r   )rq   rr   rs   sample_weightr   s        rb   rt   z"NoSampleWeightPandasSeriesType.fit  sj    !Qn4SW
 
 
1 	"!!!!!mV,, 	P   rd   c                 ^    t          |          }t          j        |j        d                   S rw   r   r|   s     rb   r}   z&NoSampleWeightPandasSeriesType.predict,  r   rd   ro   r~   rk   rd   rb   r   r     s7           # # # # #rd   r   c                       e Zd ZddZd ZdS )BadBalancedWeightsClassifierNc                     || _         d S ro   )class_weight)rq   r   s     rb   r   z%BadBalancedWeightsClassifier.__init__2  s    (rd   c                     ddl m} ddlm}  |                                |          }|j        } || j        ||          }| j        dk    r|dz  }|| _        | S )Nr   )LabelEncoder)compute_class_weight)classesrs   balanced      ?)sklearn.preprocessingr   sklearn.utilsr   rt   classes_r   r   )rq   rr   rs   r   r   label_encoderr  r   s           rb   rt   z BadBalancedWeightsClassifier.fit5  s    666666666666$**1--(++D,=wRSTTT 
**CL "
rd   ro   r   rk   rd   rb   r   r   1  s7        ) ) ) )    rd   r   c                       e Zd ZddZd ZdS )BadTransformerWithoutMixinNc                 &    t          | |          }| S ro   r   rp   s      rb   rt   zBadTransformerWithoutMixin.fitH  s    $""rd   c                 H    t          |            t          | |d          }|S )NFreset)rW   rY   r|   s     rb   	transformz$BadTransformerWithoutMixin.transformL  s)    $///rd   ro   )rg   rh   ri   rt   r  rk   rd   rb   r	  r	  G  s7               rd   r	  c                       e Zd Zd Zd ZdS )NotInvariantPredictc                 6    t          | ||ddd          \  }}| S Nr   Tr   r   rp   s      rb   rt   zNotInvariantPredict.fitS  s/    !Qn4SW
 
 
1 rd   c                     t          |          }|j        d         dk    rt          j        |j        d                   S t          j        |j        d                   S )Nr   r   )rV   r{   ry   rz   zerosr|   s     rb   r}   zNotInvariantPredict.predictZ  sH    NN71:>>7171:&&&x
###rd   Nr~   rk   rd   rb   r  r  R  s2          $ $ $ $ $rd   r  c                       e Zd Zd Zd ZdS )NotInvariantSampleOrderc                 D    t          | ||ddd          \  }}|| _        | S r  )rY   _Xrp   s      rb   rt   zNotInvariantSampleOrder.fitc  s6    !Qn4SW
 
 
1 rd   c                 4   t          |          }t          j        t          j        |d          t          j        | j        d                    r<|| j        k                                    rt          j        |j        d                   S |d d df         S )Nr   )axis)rV   ry   array_equivsortr  anyr  r{   r|   s     rb   r}   zNotInvariantSampleOrder.predictk  s    NN N2711---rwtwQ/G/G/GHH	(dg""$$	( 8AGAJ'''Awrd   Nr~   rk   rd   rb   r  r  b  s2          	 	 	 	 	rd   r  c                   (    e Zd ZdZddZddZd ZdS )	OneClassSampleErrorClassifierzoClassifier allowing to trigger different behaviors when `sample_weight` reduces
    the number of classes to 1.Fc                     || _         d S ro   )raise_when_single_class)rq   r!  s     rb   r   z&OneClassSampleErrorClassifier.__init__{  s    '>$$$rd   Nc                    t          ||ddd          \  }}d| _        t          j        |d          \  | _        }| j        j        d         }|dk     r| j        rd| _        t          d          |pt          |t          j	                  r:t          |          dk    r't          j        t          j        ||                    }|dk     rd| _        t          d	          | S )
Nr   Tr   F)return_inverser      znormal class errorr   )rX   has_single_class_ry   uniquer  r{   r!  r   r   ndarraylencount_nonzerobincount)rq   rr   rs   r   
n_classes_s        rb   rt   z!OneClassSampleErrorClassifier.fit~  s    qTT
 
 
1 "'9Qt<<<q](+
>>d:>%)D"1222 $-44 M]9K9Ka9O9O-bk!].K.KLL
A~~)-& !4555rd   c                     t          |            t          |          }| j        rt          j        |j        d                   S t          j        |j        d                   S rw   )rW   rV   r%  ry   r  r{   rz   r|   s     rb   r}   z%OneClassSampleErrorClassifier.predict  sR    NN! 	(8AGAJ'''wqwqz"""rd   )Fro   rg   rh   ri   rj   r   rt   r}   rk   rd   rb   r  r  w  sU        # #? ? ? ?   ,# # # # #rd   r  c                        e Zd ZdZddZd ZdS )!LargeSparseNotSupportedClassifierz^Estimator that claims to support large sparse data
    (accept_large_sparse=True), but doesn'tNc                     || _         d S ro   r   r   s     rb   r   z*LargeSparseNotSupportedClassifier.__init__  r   rd   c           	         t          | ||dddd          \  }}| j        dk    rt          |t          j                  }n%| j        dk    rt          |t          j                  }|rh|j        dk    r0|j        j        dk    s|j	        j        dk    rt          d          n-|j        d	v r$d|j        j        |j        j        fvs
J d            | S )
N)r   r   cooT)r   accept_large_sparser   r   r   r   r2  int64z(Estimator doesn't support 64-bit indices)r   r   )rY   r   r   r   r   r   formatrowdtypecolr   indicesindptrr   s       rb   rt   z%LargeSparseNotSupportedClassifier.fit  s   / $
 
 
1 .00%a44LL O33%a55L 	>x5  5;'))QU[G-C-C$%OPPP .D^++IOHN'    >  
 rd   ro   )rg   rh   ri   rj   r   rt   rk   rd   rb   r/  r/    sA        / /- - - -    rd   r/  c                   ,    e Zd ZddZddZddZd ZdS )SparseTransformerNc                     || _         d S ro   sparse_container)rq   r?  s     rb   r   zSparseTransformer.__init__  s     0rd   c                 &    t          | |           | S ro   r   rp   s      rb   rt   zSparseTransformer.fit  s    dArd   c                 T    |                      ||                              |          S ro   )rt   r  rp   s      rb   fit_transformzSparseTransformer.fit_transform  s"    xx1~~''***rd   c                 p    t          |            t          | |dd          }|                     |          S )NTF)r   r  )rW   rY   r?  r|   s     rb   r  zSparseTransformer.transform  s:    $UCCC$$Q'''rd   ro   )rg   rh   ri   r   rt   rB  r  rk   rd   rb   r<  r<    s_        1 1 1 1   + + + +( ( ( ( (rd   r<  c                       e Zd Zd Zd ZdS )EstimatorInconsistentForPandasc                     	 ddl m} t          ||          r|j        d         | _        nt          |          }|d         | _        | S # t          $ r! t          |          }|d         | _        | cY S w xY w)Nr   )	DataFrame)r   r   )r   r   )r   rG  r   ilocvalue_rV   ImportError)rq   rr   rs   rG  s       rb   rt   z"EstimatorInconsistentForPandas.fit  s    	((((((!Y'' &fTlNNgK 	 	 	AAD'DKKKK	s   AA	 	(A43A4c                 p    t          |          }t          j        | j        g|j        d         z            S rw   )rV   ry   arrayrI  r{   r|   s     rb   r}   z&EstimatorInconsistentForPandas.predict  s,    NNx
2333rd   Nr~   rk   rd   rb   rE  rE    s2           4 4 4 4 4rd   rE  c                   ,     e Zd Zd fd	Zd fd	Z xZS )UntaggedBinaryClassifierNc                     t                                          |||||           t          | j                  dk    rt	          d          | S )Nr$  Only 2 classes are supported)r   rt   r(  r  r   )rq   rr   rs   	coef_initintercept_initr   r   s         rb   rt   zUntaggedBinaryClassifier.fit  sJ    Aq)^]CCCt}!!;<<<rd   c                     t                                          ||||           t          | j                  dk    rt	          d          | S )N)rr   rs   r  r   r$  rP  )r   partial_fitr(  r  r   )rq   rr   rs   r  r   r   s        rb   rT  z$UntaggedBinaryClassifier.partial_fit  sM    a1g]SSSt}!!;<<<rd   )NNNNN)rg   rh   ri   rt   rT  r   r   s   @rb   rN  rN    s[                      rd   rN  c                   (     e Zd Z fdZ fdZ xZS )TaggedBinaryClassifierc                     t          |dd          }|dk    rt          d| d          t                                          ||          S )Nrs   T)
input_nameraise_unknownbinaryzCOnly binary classification is supported. The type of the target is .)rU   r   r   rt   )rq   rr   rs   y_typer   s       rb   rt   zTaggedBinaryClassifier.fit  se    cFFFX         ww{{1a   rd   c                 `    t                                                      }d|j        _        |S NF)r   __sklearn_tags__classifier_tagsmulti_classrq   tagsr   s     rb   r`  z'TaggedBinaryClassifier.__sklearn_tags__   s(    ww''))+0(rd   rg   rh   ri   rt   r`  r   r   s   @rb   rW  rW    sQ        ! ! ! ! !        rd   rW  c                   (     e Zd Z fdZ fdZ xZS )RequiresPositiveXRegressorc                     t          | ||dd          \  }}|dk                                     rt          d          t                                          ||          S )NFTr   r   r   z$Negative values in data passed to X.rY   r  r   r   rt   rq   rr   rs   r   s      rb   rt   zRequiresPositiveXRegressor.fit  s[    T1au4PPP1E;;== 	ECDDDww{{1a   rd   c                 x    t                                                      }d|j        _        d|j        _        |S )NTF)r   r`  
input_tagspositive_onlysparserc  s     rb   r`  z+RequiresPositiveXRegressor.__sklearn_tags__  s1    ww''))(,%!&rd   re  r   s   @rb   rg  rg    sQ        ! ! ! ! !        rd   rg  c                   (     e Zd Z fdZ fdZ xZS )RequiresPositiveYRegressorc                     t          | ||dd          \  }}|dk                                    rt          d          t                                          ||          S )NTri  r    negative y values not supported!rj  rk  s      rb   rt   zRequiresPositiveYRegressor.fit  s[    T1at$OOO1F<<>> 	A?@@@ww{{1a   rd   c                 `    t                                                      }d|j        _        |S NT)r   r`  target_tagsrn  rc  s     rb   r`  z+RequiresPositiveYRegressor.__sklearn_tags__  s(    ww'')))-&rd   re  r   s   @rb   rq  rq    sQ        ! ! ! ! !        rd   rq  c                   (     e Zd Z fdZ fdZ xZS )PoorScoreLogisticRegressionc                 L    t                                          |          dz   S r   )r   decision_function)rq   rr   r   s     rb   rz  z-PoorScoreLogisticRegression.decision_function$  s     ww((++a//rd   c                 `    t                                                      }d|j        _        |S ru  )r   r`  ra  
poor_scorerc  s     rb   r`  z,PoorScoreLogisticRegression.__sklearn_tags__'  s(    ww''))*.'rd   )rg   rh   ri   rz  r`  r   r   s   @rb   rx  rx  #  sQ        0 0 0 0 0        rd   rx  c                       e Zd Zd Zd ZdS )PartialFitChecksNamec                 (    t          | ||           | S ro   r   rp   s      rb   rt   zPartialFitChecksName.fit.  s    dAq!!!rd   c                 \    t          | d           }t          | |||           d| _        | S )N_fittedr  T)hasattrrY   r  )rq   rr   rs   r  s       rb   rT  z PartialFitChecksName.partial_fit2  s7    D),,,dAq....rd   N)rg   rh   ri   rt   rT  rk   rd   rb   r~  r~  -  s2              rd   r~  c                       e Zd ZdZd Zd ZdS )BrokenArrayAPIz=Make different predictions when using Numpy and the Array APIc                     | S ro   rk   rp   s      rb   rt   zBrokenArrayAPI.fit<  ru   rd   c                     t                      d         }t          j        |          \  }}|r|                    g d          S t	          j        g d          S )Narray_api_dispatch)r   r$     )r  r$  r   )r   r   get_namespaceasarrayry   rL  )rq   rr   enabledxp_s        rb   r}   zBrokenArrayAPI.predict?  sW    ,,34(++A 	'::iii(((8III&&&rd   N)rg   rh   ri   rj   rt   r}   rk   rd   rb   r  r  9  s8        GG  ' ' ' ' 'rd   r  c                     	 t          j        d           n# t          $ r t          d          w xY wt	          t
          d          5  t          dt                      dd           d d d            d S # 1 swxY w Y   d S )Narray_api_strictz-array-api-strict is required to run this testNot equal to tolerancematchr  T)array_namespacecheck_values)	importlibimport_moduleModuleNotFoundErrorr&   r(   AssertionErrorr,   r  rk   rd   rb   test_check_array_api_inputr  H  s    H 23333 H H HFGGGH 
&>	?	?	? 
 
.		
 	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
s    1
 A77A;>A;c                      t          t          j        d                    } d}t          t          |          5  t          j        |            d d d            n# 1 swxY w Y   t          j        | d           sJ d S )N
   z&Don't want to call array_function sum!r  )r*   ry   rz   r(   	TypeErrorsummay_share_memory)	not_arraymsgs     rb    test_not_an_array_array_functionr  W  s    BGBKK((I
2C			%	%	%  
y               y$///////s   AA"Ac                  \     G d dt                     } t          d |                        d S )Nc                   6    e Zd Z ed          d             ZdS )btest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethodz=Deprecated for the purpose of testing check_fit_score_takes_yc                     | S ro   rk   rp   s      rb   rt   zftest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethod.fite  s    Krd   N)rg   rh   ri   r   rt   rk   rd   rb   $TestEstimatorWithDeprecatedFitMethodr  d  s:        	S	T	T	 	 
U	T	 	 	rd   r  test)r   rC   )r  s    rb   4test_check_fit_score_takes_y_works_on_deprecated_fitr  `  sN        }   
 F$H$H$J$JKKKKKrd   c                      d} t          t          |           5  t          t                     ddd           dS # 1 swxY w Y   dS )z7Test that passing a class instead of an instance fails.zPassing a class was deprecatedr  N)r(   r  r8   r   r  s    rb   'test_check_estimator_with_class_removedr  l  s    
*C			%	%	% , ,*+++, , , , , , , , , , , , , , , , , ,s   ;??c                      d} t          dt                                 t          t          |           5  t          dt	                                 ddd           dS # 1 swxY w Y   dS )z=Test that constructor cannot have mutable default parameters.zXParameter 'p' of estimator 'HasMutableParameters' is of type object which is not allowed	Immutabler  MutableN)rJ   r   r(   r  r   r  s    rb   test_mutable_default_paramsr  s  s    	& 
 ++--   
c	*	*	* R R.y:N:P:PQQQR R R R R R R R R R R R R R R R R Rs   AA#&A#c                     d} t          t          |           5  t          dt                                 ddd           n# 1 swxY w Y   t	          j        d          5 }t          dt                                 ddd           n# 1 swxY w Y   t          d |D             v sJ t          t          |           5  t          dt                                 ddd           dS # 1 swxY w Y   dS )z8Check set_params doesn't fail and sets the right values.z>get_params result does not match what was passed to set_paramsr  r  NTrecordc                     g | ]	}|j         
S rk   category.0recs     rb   
<listcomp>z)test_check_set_params.<locals>.<listcomp>  s    ;;;C3<;;;rd   )	r(   r  rO   r   warningscatch_warningsr   UserWarningr   )r  recordss     rb   test_check_set_paramsr    s    KC	c	*	*	* G G!C!E!EFFFG G G G G G G G G G G G G G G 
	 	-	-	- ;!7!9!9:::; ; ; ; ; ; ; ; ; ; ; ; ; ; ;;;7;;;;;;;	c	*	*	* 9 9!5!7!78889 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9s5   AA	A"BBBC++C/2C/c                      d} t          t          |           5  t          dt                                 d d d            d S # 1 swxY w Y   d S )NzCEstimator NoCheckinPredict doesn't check for NaN and inf in predictr  r   )r(   r  r?   r   r  s    rb   test_check_estimators_nan_infr    s    
OC	c	*	*	* I I !35E5G5GHHHI I I I I I I I I I I I I I I I I I   AA
Ac                      d} t          t          |           5  t          dt                                 d d d            d S # 1 swxY w Y   d S )Nz)Estimator changes __dict__ during predictr  r  )r(   r  r6   r   r  s    rb   test_check_dict_unchangedr    s     6C	c	*	*	* 4 4V[]]3334 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4r  c                      	 ddl m}  d}t          t          |          5  t	          dt                                 d d d            d S # 1 swxY w Y   d S # t          $ r Y d S w xY w)Nr   r   zkEstimator NoSampleWeightPandasSeriesType raises error if 'sample_weight' parameter is of type pandas.Seriesr  r   )r   r   r(   r   rN   r   rJ  )r   r  s     rb   'test_check_sample_weights_pandas_seriesr    s    !!!!!!A 	 Jc*** 	 	.02P2R2R  	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	    s3   A A
A 
AA AA 
A%$A%c                      d} t          t          |           5  t          dt                                 d d d            n# 1 swxY w Y   t          dt	                                 d S )NzrEstimator ChangesWrongAttribute should not change or mutate  the parameter wrong_attribute from 0 to 1 during fit.r  r   r  )r(   r  r@   r   r   r  s    rb   &test_check_estimators_overwrite_paramsr    s    	@  
c	*	*	* 
 
)#%:%<%<	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 &f.H.J.JKKKKK   AA	Ac                      d} t          t          |           5  t          dt                                 d d d            d S # 1 swxY w Y   d S )NzEstimator adds public attribute\(s\) during the fit method. Estimators are only allowed to add private attributes either started with _ or ended with _ but wrong_attribute addedr  r  )r(   r  r7   r   r  s    rb   $test_check_dont_overwrite_parametersr    s    	,  
c	*	*	* F F'0B0D0DEEEF F F F F F F F F F F F F F F F F Fr  c                      t           j        } d}d                    ||           }t          t          |          5  t          dt                                 d d d            d S # 1 swxY w Y   d S )Nr}   zY{method} of {name} is not invariant when applied to a datasetwith different sample order.methodnamer  r  )r  rg   r5  r(   r  rD   r  r  r  s      rb   *test_check_methods_sample_order_invariancer    s    "+DF	'fFf&&  
c	*	*	* 
 
-%'>'@'@	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   A&&A*-A*c                      t           j        } d}d                    ||           }t          t          |          5  t          dt                                 d d d            d S # 1 swxY w Y   d S )Nr}   z={method} of {name} is not invariant when applied to a subset.r  r  r  )r  rg   r5  r(   r  rE   r  s      rb   $test_check_methods_subset_invariancer    s    'DFJ
R
RD S  C 
c	*	*	* V V'(=?R?T?TUUUV V V V V V V V V V V V V V V V V Vr  c                     t           j        } d| z  }t          t          |          5  t	          | t          d                     d d d            n# 1 swxY w Y   t
          rKt          t          |          5  t          | t          d                     d d d            n# 1 swxY w Y   d}t          t          |          5  t	          dt          d                     d d d            n# 1 swxY w Y   t
          rNt          t          |          5  t          dt          d                     d d d            d S # 1 swxY w Y   d S d S )Nz;Estimator %s doesn't seem to fail gracefully on sparse datar  r   r   ztEstimator LargeSparseNotSupportedClassifier doesn't seem to support \S{3}_64 matrix, and is not failing gracefully.*r/  )r   rg   r(   r  r<   rS   r;   r/  r  r  s     rb    test_check_estimator_sparse_datar    s   &D
G$
NC	c	*	*	* Q Q%d,>,O,OPPPQ Q Q Q Q Q Q Q Q Q Q Q Q Q Q  SN#... 	S 	S(/A./Q/QRRR	S 	S 	S 	S 	S 	S 	S 	S 	S 	S 	S 	S 	S 	S 	S
	D  
c	*	*	* 
 
%/-o>>	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
  N#... 	 	(31.AA  	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 sG   AAA:B$$B(+B(C11C58C5EEEc                      t           j        } |  d}t          t          |          5  t	          dt                                 d d d            d S # 1 swxY w Y   d S )Nzu failed when fitted on one label after sample_weight trimming. Error message is not explicit, it should have 'class'.r  r  )r  rg   r(   r  r3   r  s     rb   /test_check_classifiers_one_label_sample_weightsr    s    (1D 	 	 	 
 
c	*	*	* 
 
2+-J-L-L	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
s   AAAc                  :   t          t                      d          } t          | t                    sJ t	          |           dk    sJ t          d | D                       sJ t          d | D                       sJ t          d | D                       sJ dS )zCheck the contents of the results returned with on_fail!="raise".

    This results should contain details about the observed failures, expected
    or not.
    N)on_failr   c              3      K   | ]@}t          |t                    o&t          |                                          h d k    V  AdS )>   status	estimator	exception
check_nameexpected_to_failexpected_to_fail_reasonN)r   dictsetkeysr  items     rb   	<genexpr>z5test_check_estimator_not_fail_fast.<locals>.<genexpr>  sn          	4 		
		
 
 

     rd   c              3   .   K   | ]}|d          dk    V  dS )r  failedNrk   r  s     rb   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>'  +      DDdtH~)DDDDDDrd   c              3   .   K   | ]}|d          dk    V  dS )r  passedNrk   r  s     rb   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>(  r  rd   )r8   r   r   listr(  allr  )check_resultss    rb   "test_check_estimator_not_fail_fastr    s     $MOOTBBBMmT*****}!!!!   "        DDmDDDDDDDDDDmDDDDDDDDDDrd   c                  ^   d} t          t          |           5  t          t                                 d d d            n# 1 swxY w Y   d} t          t          |           5  t          t                                 d d d            n# 1 swxY w Y   t          D ]}t          t          |                      t          t                                 t          t          d                     t          t                                 t          t                                 t          t                                 d} t          t          |           5  t          t                                 d d d            n# 1 swxY w Y   t          t                                 d S )Nzobject has no attribute 'fit'r  rP  r>  g{Gz?)Crs  )r(   AttributeErrorr8   r   r   rN  rR   r<  r   r   rW  rg  rq  rx  )r  csr_containers     rb   test_check_estimatorr  .  sJ    *C	c	*	*	* ) )((() ) ) ) ) ) ) ) ) ) ) ) ) ) ) )C	
#	&	&	& 4 40223334 4 4 4 4 4 4 4 4 4 4 4 4 4 4 ( K K)=IIIJJJJ &(()))&...///'))*** *,,---.00111 -C	
#	&	&	& 6 62445556 6 6 6 6 6 6 6 6 6 6 6 6 6 6 /1122222s5   AAA$BBBFFFc                      t          j        g d          } t          t                    5  t	          dd|            d d d            n# 1 swxY w Y   t          j        g d          } t	          dd|            d S )N)        r  g      ?       @r   r$  )r  r  r  r  )ry   rL  r(   r  rI   )decisions    rb   test_check_outlier_corruptionr  S  s    x,,,--H			 1 1 Ax0001 1 1 1 1 1 1 1 1 1 1 1 1 1 1 x,,,--HQ8,,,,,s   A		AAc                  b    G d dt                     } ddddddddddt          dddt          dg}|D ]} | |d         |d                   }|d	         t          |j        j        |           =t          |d	                   5  t          |j        j        |           ddd           n# 1 swxY w Y   t          d
          t          d          fD ]U} | dd|          }t          t                    5  t          |j        j        |           ddd           n# 1 swxY w Y   VdS )zTTest that check_estimator_sparse_tag raises error when sparse tag is
    misaligned.c                   .     e Zd ZddZddZ fdZ xZS )Btest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfigNc                 0    || _         || _        || _        d S ro   )
tag_sparser   	fit_error)rq   r  r   r   s       rb   r   zKtest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.__init__b  s    (DO!.D&DNNNrd   c                 R    | j         r| j         t          | ||| j                   | S )Nr   )r   rY   r   rp   s      rb   rt   zFtest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.fitg  s3    ~ %n$$1D4FGGGGKrd   c                 j    t                                                      }| j        |j        _        |S ro   )r   r`  r  rm  ro  rc  s     rb   r`  zStest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.__sklearn_tags__m  s)    77++--D%)_DO"Krd   ro   rg   rh   ri   r   rt   r`  r   r   s   @rb   EstimatorWithSparseConfigr  a  s`        	' 	' 	' 	'
	 	 	 		 	 	 	 	 	 	 	 	rd   r  TN)r  r   
error_typeFr  r   r  zunexpected errorzother error)r   r  r=   r   rg   r(   r  KeyError)r  
test_cases	test_caser  r   s        rb   test_check_estimator_sparse_tagr	  ]  s(       M   $ d$GGuDIIt>RRe>RR	J   	T 	T	--l#o&
 
	 \"*&y':'CYOOOO	,/00 T T*9+>+GSSST T T T T T T T T T T T T T T
   233Xm5L5LM P P	--eUIFF	N## 	P 	P&y':'CYOOO	P 	P 	P 	P 	P 	P 	P 	P 	P 	P 	P 	P 	P 	P 	PP Ps$   B//B3	6B3	<D##D'	*D'	c                      t          t          d          5  t          t                                 d d d            d S # 1 swxY w Y   d S )Nz%the `transformer_tags` tag is not set)r(   RuntimeErrorr8   r	  rk   rd   rb   )test_check_estimator_transformer_no_mixinr    s     
E	F	F 6 62445556 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6s   ?AAc                     t                      } t          t          t          t          t
          fD ]G}t          t                    5   |            }t          |           t          j
        |          }t          |t          |                     d d d            n# 1 swxY w Y   |t          j
        |          k    sJ t          t                    5   |            }t          |           |                    | j        | j                   t          j
        |          }t          |t          |                     d d d            n# 1 swxY w Y   |t          j
        |          k    sJ Id S )Nr  expected_failed_checks)r   r   r   r   r   r   r'   r   rQ   joblibhashr8   r"   rt   datatarget)iris	Estimatorestold_hashs       rb   test_check_estimator_clonesr    s    ;;D 	 , ,	 &8999 	 	)++CS!!!{3''H,G,L,L   		 	 	 	 	 	 	 	 	 	 	 	 	 	 	 6;s++++++ &8999 	 	)++CS!!!GGDIt{+++{3''H,G,L,L   	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 6;s+++++++5, ,s&   ABB#	&B#	A,EE	E	c                      d} t          t          |           5  t          dt                                 d d d            n# 1 swxY w Y   t          dt	                                 d S )Nz4Estimator should raise a NotFittedError when callingr  r  )r(   r  rA   r   r   r  s    rb   test_check_estimators_unfittedr    s     AC	c	*	*	* E E!+/A/C/CDDDE E E E E E E E E E E E E E E
 k+J+L+LMMMMMr  c                  r    G d dt                     }  G d dt                     } G d dt                     }d}t          t          |          5  t          d	 |                        d d d            n# 1 swxY w Y   d
}t          t          |          5  t          d	 |                       d d d            n# 1 swxY w Y   t          d	 |                       t          d          5  t          d	 |                                d                     d d d            d S # 1 swxY w Y   d S )Nc                       e Zd Zd ZdS )Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSetc                     d | _         d S ro   )you_should_not_set_this_rq   s    rb   r   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSet.__init__  s    ,0D)))rd   Nrg   rh   ri   r   rk   rd   rb    NonConformantEstimatorPrivateSetr    s#        	1 	1 	1 	1 	1rd   r"  c                       e Zd ZddZdS )Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSetNc                     d S ro   rk   )rq   you_should_set_this_s     rb   r   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSet.__init__  s    Drd   ro   r!  rk   rd   rb    NonConformantEstimatorNoParamSetr$    s(        	 	 	 	 	 	rd   r'  c                       e Zd ZddiZddZdS )Otest_check_no_attributes_set_in_init.<locals>.ConformantEstimatorClassAttributefooTNc                     | S ro   rk   rp   s      rb   rt   zStest_check_no_attributes_set_in_init.<locals>.ConformantEstimatorClassAttribute.fit      Krd   ro   )rg   rh   ri   9_ConformantEstimatorClassAttribute__metadata_request__fitrt   rk   rd   rb   !ConformantEstimatorClassAttributer)    s2        #($-	 	 	 	 	 	rd   r.  zEstimator estimator_name should not set any attribute apart from parameters during init. Found attributes \['you_should_not_set_this_'\].r  estimator_namezPEstimator estimator_name should store all parameters as an attribute during initT)enable_metadata_routing)r*  )r   r(   r  rG   r  r   set_fit_request)r"  r'  r.  r  s       rb   $test_check_no_attributes_set_in_initr2    sv   1 1 1 1 1= 1 1 1    =       M   	= 
 
c	*	*	* 
 
'>>@@	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
	  
c	*	*	* 
 
'>>@@	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 $;;==   
	5	5	5 
 
'--//??D?II	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
s6   A77A;>A;B??CC2-D,,D03D0c                      t          d          } t          |            t          d          } t          | t          |                      d S )Nprecomputed)kernel)metricr  )r   r8   r   r"   )r  s    rb   test_check_estimator_pairwiser7    sV     ]
#
#
#CC ]
3
3
3CC0KC0P0PQQQQQQrd   c                      t          t          d          5  t          dt                                 d d d            d S # 1 swxY w Y   d S Nr  r  r/  )r(   r  r.   rE  rk   rd   rb   'test_check_classifier_data_not_an_arrayr:    s    	&>	?	?	? 
 
*<>>	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   AAAc                      t          t          d          5  t          dt                                 d d d            d S # 1 swxY w Y   d S r9  )r(   r  rL   rE  rk   rd   rb   &test_check_regressor_data_not_an_arrayr=  
  s    	&>	?	?	? 
 
)<>>	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
r;  c                     d} t          t          |           5  t          dt                                 d d d            n# 1 swxY w Y   t          dt	                                 t                      }t          |j        j        |           d|_        d} t          t          |           5  t          |j        j        |           d d d            d S # 1 swxY w Y   d S )Nz+Estimator does not have a feature_names_in_r  r/  z;Docstring that does not document the estimator's attributeszNEstimator LogisticRegression does not document its feature_names_in_ attribute)	r(   r   r4   rm   r~  r   r   rg   rj   )err_msglrs     rb   -test_check_dataframe_column_names_consistencyrA    s   ;G	
'	*	*	* X X01ACTCVCVWWWX X X X X X X X X X X X X X X,-=?S?U?UVVV			B,R\-BBGGGNBJX  

'	*	*	* L L01FKKKL L L L L L L L L L L L L L L L L Ls#   AA	A0CCCc                   *     e Zd Zd Zd Z fdZ xZS )_BaseMultiLabelClassifierMockc                     || _         d S ro   response_output)rq   rF  s     rb   r   z&_BaseMultiLabelClassifierMock.__init__"  r   rd   c                     | S ro   rk   rp   s      rb   rt   z!_BaseMultiLabelClassifierMock.fit%  ru   rd   c                 `    t                                                      }d|j        _        |S ru  )r   r`  ra  multi_labelrc  s     rb   r`  z._BaseMultiLabelClassifierMock.__sklearn_tags__(  s(    ww''))+/(rd   r  r   s   @rb   rC  rC  !  sV        / / /          rd   rC  c            	         d\  } }}t          | d|dddd          \  }}|| d          } G d d	t                    } ||                                
          }d}t          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y    ||d d d df         
          }d}t          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y    ||                    t          j
                  
          }d}t          t          |          5  t          |j        j        |           d d d            d S # 1 swxY w Y   d S )Nd         r$  r  2   Tr   	n_samples
n_features	n_classesn_labelslengthallow_unlabeledrandom_statec                       e Zd Zd ZdS )\test_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredictc                     | j         S ro   rE  r|   s     rb   r}   zdtest_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredict.predict<      ''rd   N)rg   rh   ri   r}   rk   rd   rb   MultiLabelClassifierPredictrY  ;  #        	( 	( 	( 	( 	(rd   r\  rE  zdMultiLabelClassifierPredict.predict is expected to output a NumPy array. Got <class 'list'> instead.r  zbMultiLabelClassifierPredict.predict outputs a NumPy array of shape \(25, 4\) instead of \(25, 5\).zTMultiLabelClassifierPredict.predict does not output the same dtype than the targets.)r   rC  tolistr(   r  r1   r   rg   astypery   float64)	rQ  	test_size	n_outputsr  rs   y_testr\  clfr?  s	            rb   7test_check_classifiers_multilabel_output_format_predictrf  .  s   &0#Iy))  DAq 	z{{^F( ( ( ( (&C ( ( (
 &
%fmmoo
F
F
FC	4  
g	.	.	. X X:3=;QSVWWWX X X X X X X X X X X X X X X &
%fQQQVn
E
E
EC	1  
g	.	.	. X X:3=;QSVWWWX X X X X X X X X X X X X X X &
%fmmBJ6O6O
P
P
PC	#  
g	.	.	. X X:3=;QSVWWWX X X X X X X X X X X X X X X X X Xs6   4BB"BC==DD	E11E58E5c            	      N  
 d\  } }}t          | d|dddd          \  }}|| d          
 G d d	t                    }t          D ]j} | |
          
          }d|j         d}t	          t
          |          5  t          |j        j        |           d d d            n# 1 swxY w Y   k |
                                
          }d| d| d}t	          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y   
fdt          |          D             }	 ||	
          }d}t	          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y   
fdt          |          D             }	 ||	
          }d}t	          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y   
fdt          |          D             }	 ||	
          }d}t	          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y    |
d d d df         
          }d}t	          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y   t          j        
t          j                  }	 ||	
          }d}t	          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y    |
dz  
          }d}t	          t          |          5  t          |j        j        |           d d d            d S # 1 swxY w Y   d S )NrK  r$  r  rO  Tr   rP  c                       e Zd Zd ZdS )gtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProbac                     | j         S ro   rE  r|   s     rb   predict_probazutest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProba.predict_probag  r[  rd   N)rg   rh   ri   rk  rk   rd   rb    MultiLabelClassifierPredictProbari  f  r]  rd   rl  rE  zUnknown returned type .*zZ.* by MultiLabelClassifierPredictProba.predict_proba. A list or a Numpy array is expected.r  zWhen MultiLabelClassifierPredictProba.predict_proba returns a list, the list should be of length n_outputs and contain NumPy arrays. Got length of z instead of r\  c                 8    g | ]}t          j                  S rk   )ry   	ones_liker  r  rd  s     rb   r  zQtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.<listcomp>  s#    FFFr|F++FFFrd   zWhen MultiLabelClassifierPredictProba.predict_proba returns a list, this list should contain NumPy arrays of shape \(n_samples, 2\). Got NumPy arrays of shape \(25, 5\) instead of \(25, 2\).c                 j    g | ]/}t          j        j        d          dft           j                  0S r   r$  )r{   r7  )ry   rz   r{   r4  ro  s     rb   r  zQtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.<listcomp>  sB       @Av|A*"(;;;  rd   zwWhen MultiLabelClassifierPredictProba.predict_proba returns a list, it should contain NumPy arrays with floating dtype.c                 j    g | ]/}t          j        j        d          dft           j                  0S rq  )ry   rz   r{   ra  ro  s     rb   r  zQtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.<listcomp>  sB       BCv|A*"*===  rd   zWhen MultiLabelClassifierPredictProba.predict_proba returns a list, each NumPy array should contain probabilities for each class and thus each row should sum to 1r^  zWhen MultiLabelClassifierPredictProba.predict_proba returns a NumPy array, the expected shape is \(n_samples, n_outputs\). Got \(25, 4\) instead of \(25, 5\).)r7  znWhen MultiLabelClassifierPredictProba.predict_proba returns a NumPy array, the expected data type is floating.r  zWhen MultiLabelClassifierPredictProba.predict_proba returns a NumPy array, this array is expected to provide probabilities of the positive class and should therefore contain values between 0 and 1.)r   rC  rR   rg   r(   r   r2   r   r_  r  rangery   
zeros_liker4  )rQ  rb  rc  r  rs   rl  r  re  r?  rF  rd  s             @rb   =test_check_classifiers_multilabel_output_format_predict_probaru  Y  s   &0#Iy))  DAq 	z{{^F( ( ( ( (+H ( ( ( (  ..}}V?T?TUUU"}'= " " " 	
 Jg... 	 	D&  	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 +
*6==??
K
K
KC	9	9 	9,5	9 	9 	9 
 
g	.	.	. 
 
@M"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 GFFFU95E5EFFFO
*
*?
K
K
KC	A 
 
g	.	.	. 
 
@M"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
   EJ9EUEU  O +
*?
K
K
KC	>  
g	.	.	. 
 
@M"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
   GLYGWGW  O +
*?
K
K
KC	) 
 
g	.	.	. 
 
@M"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 +
*6!!!SbS&>
J
J
JC	" 
 
g	.	.	. 
 
@M"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 mF"(;;;O
*
*?
K
K
KC	6  
g	.	.	. 
 
@M"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 +
*6C<
H
H
HC	O 
 
g	.	.	. 
 
@M"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
s   >B%%B)	,B)	.DDDFF
F
G77G;>G;I((I,/I,#K

KKM  MM2NN!Nc            	         d\  } }}t          | d|dddd          \  }}|| d          } G d d	t                    } ||                                
          }d}t          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y    ||d d d df         
          }d}t          t          |          5  t          |j        j        |           d d d            n# 1 swxY w Y    ||
          }d}t          t          |          5  t          |j        j        |           d d d            d S # 1 swxY w Y   d S )NrK  r$  r  rO  Tr   rP  c                       e Zd Zd ZdS )otest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunctionc                     | j         S ro   rE  r|   s     rb   rz  ztest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunction.decision_function  r[  rd   N)rg   rh   ri   rz  rk   rd   rb   $MultiLabelClassifierDecisionFunctionrx    r]  rd   rz  rE  zwMultiLabelClassifierDecisionFunction.decision_function is expected to output a NumPy array. Got <class 'list'> instead.r  r^  zMultiLabelClassifierDecisionFunction.decision_function is expected to provide a NumPy array of shape \(n_samples, n_outputs\). Got \(25, 4\) instead of \(25, 5\)z^MultiLabelClassifierDecisionFunction.decision_function is expected to output a floating dtype.)r   rC  r_  r(   r  r0   r   rg   )	rQ  rb  rc  r  rs   rd  rz  re  r?  s	            rb   Atest_check_classifiers_multilabel_output_format_decision_functionr{    s   &0#Iy))  DAq 	z{{^F( ( ( ( (/L ( ( (
 /
.v}}
O
O
OC	@  
g	.	.	. 
 
DM"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 /
.vaaa"f~
N
N
NC	* 
 
g	.	.	. 
 
DM"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 /
.v
F
F
FC	'  
g	.	.	. 
 
DM"	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
s6   4BB"BC==DD,EEEc                     t           j        d         fdt                    D             } d | D             }t          j                    }|                    |           t          j                    }|                    |           dS )z1Runs the tests in this file without using pytest.__main__c                 Z    g | ]'}|                     d           t          |          (S )test_)
startswithgetattr)r  r  main_modules     rb   r  z,run_tests_without_pytest.<locals>.<listcomp>  sE       ??7##T""  rd   c                 6    g | ]}t          j        |          S rk   )unittestFunctionTestCase)r  fns     rb   r  z,run_tests_without_pytest.<locals>.<listcomp>  s#    IIIB(+B//IIIrd   N)r\   r]   dirr  	TestSuiteaddTestsTextTestRunnerrun)test_functionsr  suiterunnerr  s       @rb   run_tests_without_pytestr  
  s    +j)K   $$  N
 JI.IIIJ  E	NN:$&&F
JJurd   c                      d} t          t          |           5  t          dt                                 d d d            d S # 1 swxY w Y   d S )NzIClassifier estimator_name is not computing class_weight=balanced properlyr  r/  )r(   r  r-   r   r  s    rb   2test_check_class_weight_balanced_linear_classifierr    s    
UC	c	*	*	* 
 
5:<<	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
r  c                      t          j        d          5 } t                      }d d d            n# 1 swxY w Y   | rJ |D ]#}|j        j                            d          rJ $d S )NTr  r  )r  r  r   r   rg   r  )r  
estimatorsr  s      rb   test_all_estimators_all_publicr  "  s     
	 	-	-	- &#%%
& & & & & & & & & & & & & & & : : :=)44S999999: :s   155r}  c                  2   t          t          t                              } t          |           }t	          | d|d          }t          |          dk    sJ d |D             }t          |          dk    sJ |D ]}|j        d         }d|j        vsJ d S )NTxfaillegacyr  r_   r   c                 2    g | ]}t          |d           |S marksr  r  cs     rb   r  z?test_estimator_checks_generator_strict_none.<locals>.<listcomp>B  '    >>>1'!W*=*=>Q>>>rd   strict)nextr!   r   r"   rP   r(  r  r   )r  r  checksmarked_checksparameter_set
first_marks         rb   +test_estimator_checks_generator_strict_noner  4  s    
#E**
+
+C2377 (/	  F   1$$$$>>>>>M}!!!!& 1 1"(+
z0000001 1rd   c                     t          t          t                              } t          |           }t	          | d|dd          }t          |          dk    sJ g }d |D             }t          |          dk    sJ |D ]H}|j        \  }}|j        d         }|j        d         r"|	                    t          |                     It          |                                          t          |          k    sJ d S )NTr  )r  r  r_   xfail_strictr   c                 2    g | ]}t          |d           |S r  r  r  s     rb   r  zFtest_estimator_checks_generator_strict_xfail_tests.<locals>.<listcomp>]  r  rd   r  )r  r!   r   r"   rP   r(  valuesr  r   appendr)   r  r  )	r  r  r  strict_xfailed_checksr  r  r  checkr  s	            rb   2test_estimator_checks_generator_strict_xfail_testsr  K  s(    #E**
+
+C2377'/  F   1$$$$ ?>>>>M  1$$$$& = = '5"(+
X& 	=!((U););<<< $$&&''3/D+E+EEEEEEErd   c                     t          t          t                              } t          |           }t	          | d|d          }t          |          dk    sJ g }|D ]C\  }}	  ||           # t          $ r% |                    t          |                     Y @w xY wt          |
                                          t          |          k    sJ d S )NTskipr  r   )r  r!   r   r"   rP   r(  r&   r  r)   r  r  )r  r  r  skipped_checksr  r  s         rb   .test_estimator_checks_generator_skipping_testsr  k  s    #E**
+
+C2377'D1A  F   1$$$$N" 6 6	5	6E) 	6 	6 	6!!+e"4"455555	6 $$&&''3~+>+>>>>>>>s   #A//,BBc                     t                      } t          |           }t          |          dk    sJ t          j        d          5 }t          | |d          }ddd           n# 1 swxY w Y   d |D             }t          d |D                       sJ t          |          t          |          k    sJ d	 |D             }t          |          t          |          k    sJ dS )
zTest that the right number of xfail warnings are raised when on_fail is "warn".

    It also checks the number of raised EstimatorCheckFailedWarning, and checks the
    output of check_estimator.
    r   Tr  warn)r  r  Nc                 2    g | ]}|j         t          k    |S rk   )r  r   )r  ws     rb   r  z6test_xfail_count_with_no_fast_fail.<locals>.<listcomp>  s$    GGG)F)F1)F)F)Frd   c                 .    g | ]}|j         t          k    S rk   )r  r   r  s     rb   r  z6test_xfail_count_with_no_fast_fail.<locals>.<listcomp>  s     SSS ;;SSSrd   c                 *    g | ]}|d          dk    |S )r  r  rk   )r  logs     rb   r  z6test_xfail_count_with_no_fast_fail.<locals>.<listcomp>  s&    ???sc(mw&>&>s&>&>&>rd   )r   r"   r(  r  r  r8   r  )r  r  r  logsxfail_warnsxfaileds         rb   "test_xfail_count_with_no_fast_failr    sL    ''C8==%&&****		 	-	-	- 
#9
 
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 HGgGGGKSS{SSSTTTTT{s#9::::::??d???Gw<<3566666666s   A''A+.A+c                     dddddfd} t                      }t          |          }t          |          dk    sJ t          j        d          5  t          ||d|            ddd           n# 1 swxY w Y   t          t          t          |d                              }d	         t          |          k    sJ d
         dk    sJ d         dk    sJ d         |d	         z
  d
         z
  k    sJ dS )z:Test that the callback is called with the right arguments.r   r  skippedr  r  c                 4    |dv sJ |xx         dz  cc<   d S )Nr  r   rk   )r  r  r  r  r  r  
call_counts         rb   callbackz/test_check_estimator_callback.<locals>.callback  s9     AAAAA6ard   Tr  N)r  r  r  r  r  r  r  r  )r   r"   r(  r  r  r8   r  rP   )r  r  r  all_checks_countr  s       @rb   test_check_estimator_callbackr    s   a1EEJ          ''C8==%&&****		 	-	-	- 
 
#9		
 	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 4 :3t L L LMMNNg#&<"="=====h!####h1$$$$i :g..H1EE     s   A55A9<A9c                      t           ro   )r&   r%   r$   r#   r8   )minimal_estimatorsr  s     rb   (test_minimal_class_implementation_checksr    s	     Nrd   c                  $    G d dt                     } t          t          d          5  t          d | d                     d d d            n# 1 swxY w Y   t          d | d                     t          d | d	                     d S )
Nc                   F    e Zd ZddZd Z ed           d             ZdS )1test_check_fit_check_is_fitted.<locals>.Estimator	attributec                     || _         d S ro   behavior)rq   r  s     rb   r   z:test_check_fit_check_is_fitted.<locals>.Estimator.__init__  s    $DMMMrd   c                 P    | j         dk    rd| _        n| j         dk    rd| _        | S )Nr  Tr  )r  
is_fitted_
_is_fitted)rq   rr   rs   r   s       rb   rt   z5test_check_fit_check_is_fitted.<locals>.Estimator.fit  s1    }++"&(**"&Krd   c                     | j         dv S )N>   r  always-truer  r   s    rb   <lambda>z:test_check_fit_check_is_fitted.<locals>.Estimator.<lambda>  s    4=4M#M rd   c                 <    | j         dk    rdS t          | d          S )Nr  Tr  )r  r  r   s    rb   __sklearn_is_fitted__zGtest_check_fit_check_is_fitted.<locals>.Estimator.__sklearn_is_fitted__  s$    }--t4...rd   N)r  )rg   rh   ri   r   rt   rT   r  rk   rd   rb   r  r    sb        	% 	% 	% 	%	 	 	 
MM	N	N	/ 	/ 
O	N	/ 	/ 	/rd   r  z'passes check_is_fitted before being fitr  r  r  r  r  r  )r   r(   	ExceptionrB   )r  s    rb   test_check_fit_check_is_fittedr    s   / / / / /M / / /" 
	!J	K	K	K R R!+yy-/P/P/PQQQR R R R R R R R R R R R R R R k99h+G+G+GHHHk99k+J+J+JKKKKKs   AAAc                      G d dt                     } t          j        d          5 }t          d |                        d d d            n# 1 swxY w Y   d |D             rJ  G d dt                     }d	}t	          t
          |
          5  t          d |                       d d d            d S # 1 swxY w Y   d S )Nc                       e Zd Zd ZdS )-test_check_requires_y_none.<locals>.Estimatorc                 ,    t          ||          \  }}d S ro   )rX   rp   s      rb   rt   z1test_check_requires_y_none.<locals>.Estimator.fit  s    Q??DAqqqrd   Nr   rk   rd   rb   r  r    s#        	# 	# 	# 	# 	#rd   r  Tr  r  c                     g | ]	}|j         
S rk   )message)r  r   s     rb   r  z.test_check_requires_y_none.<locals>.<listcomp>  s    ***a	***rd   c                       e Zd Zd ZdS );test_check_requires_y_none.<locals>.EstimatorWithWrongErrorc                     	 t          ||          \  }}d S # t          $ r)}t          |          dk    sJ t          d          d }~ww xY w)Nz;estimator requires y to be passed, but the target y is Nonez+This is the wrong message that raises error)rX   r   str)rq   rr   rs   ves       rb   rt   z?test_check_requires_y_none.<locals>.EstimatorWithWrongError.fit  ss    	P A111 P P P 2wwQ    !!NOOOPs    
A
$AA
Nr   rk   rd   rb   EstimatorWithWrongErrorr    s(        
	P 
	P 
	P 
	P 
	Prd   r  zxYour estimator raised a ValueError, but with the incorrect or incomplete error message to be considered a graceful fail.r  )r   r  r  rM   r(   r   )r  r  r  r?  s       rb   test_check_requires_y_noner    s   # # # # #M # # # 
	 	-	-	- 8k99;;7778 8 8 8 8 8 8 8 8 8 8 8 8 8 8 +*6******P P P P P- P P P	E  

'	*	*	* F Fk+B+B+D+DEEEF F F F F F F F F F F F F F F F F Fs#   AAAB88B<?B<c                  @   t           t          t          fD ]} t          t	           |             d                    }t
          |v sJ t          |v sJ  G d d|           }t          t	           |            d                    }t
          |vsJ t          |vsJ d S )NTr  c                        e Zd Z fdZ xZS )@test_non_deterministic_estimator_skip_tests.<locals>.MyEstimatorc                 V    t                                                      }d|_        |S ru  )r   r`  non_deterministicrc  s     rb   r`  zQtest_non_deterministic_estimator_skip_tests.<locals>.MyEstimator.__sklearn_tags__  s%    ww//11)-&rd   rg   rh   ri   r`  r   r   s   @rb   MyEstimatorr    s8                rd   r  )r%   r$   r#   r  r+   rD   rE   )r  	all_testsr  s      rb   +test_non_deterministic_estimator_skip_testsr    s     )*:<MN @ @	*99;;tDDDEE	4	AAAA.);;;;	 	 	 	 	) 	 	 	 *;;==FFFGG	4IEEEE.i?????@ @rd   c            	      V    G d dt           t                    }  |             }t          |j        j        |          J  G d d|           } |            }d}t          t          |          5  t          |j        j        |           ddd           n# 1 swxY w Y   t          t          dd	d
          g|j	        d<    |            }t          |j        j        |           t          t          ddd
          t          t          ddd
          t          t          ddd
          t          t          dd	d          g}d}|D ]_}|g|j	        d<    |            }t          t          |          5  t          |j        j        |           ddd           n# 1 swxY w Y   `dS )zHCheck the test for the contamination parameter in the outlier detectors.c                   *    e Zd ZdZddZddZd	dZdS )
Jtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraintz.Outlier detector without parameter validation.皙?c                     || _         d S ro   )contamination)rq   r  s     rb   r   zStest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.__init__  s    !.Drd   Nc                     | S ro   rk   )rq   rr   rs   r   s       rb   rt   zNtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.fit"  r,  rd   c                 @    t          j        |j        d                   S rw   rx   rp   s      rb   r}   zRtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.predict%  s    7171:&&&rd   )r  rU  ro   r-  rk   rd   rb    OutlierDetectorWithoutConstraintr    sV        <<	/ 	/ 	/ 	/	 	 	 		' 	' 	' 	' 	' 	'rd   r  Nc                   ,    e Zd Zd edh          giZdS )Gtest_check_outlier_contamination.<locals>.OutlierDetectorWithConstraintr  autoN)rg   rh   ri   r    _parameter_constraintsrk   rd   rb   OutlierDetectorWithConstraintr  -  s*        "1JJx4H4H3I!Jrd   r  zDcontamination constraints should contain a Real Interval constraint.r  r   g      ?right)closedr  r   r^  r$  leftz<contamination constraint should be an interval in \(0, 0.5\])r
   r   rH   r   rg   r(   r  r   r   r  r   )r  detectorr  r?  incorrect_intervalsintervals         rb    test_check_outlier_contaminationr    s   

' 
' 
' 
' 
'< 
' 
' 
' 0/11H&x'9'BHMMUUUK K K K K(H K K K -,..HTG	g	.	.	. K K#H$6$?JJJK K K K K K K K K K K K K K K
 	q#g...M!8I -,..H 2 ;XFFF 	1a000r1W---q!G,,,q#f---	 NG' O OQ
%<_M 1022N'222 	O 	O'(:(CXNNN	O 	O 	O 	O 	O 	O 	O 	O 	O 	O 	O 	O 	O 	O 	OO Os$   0BBB6FF!	$F!	c                  F    t          d          } t          d|            dS )zCheck that in case with some probabilities ties, we relax the
    ranking comparison with the decision function.
    Non-regression test for:
    https://github.com/scikit-learn/scikit-learn/issues/24025
    log_loss)lossr   N)r   r5   )r  s    rb   test_decision_proba_tie_rankingr	  M  s*     :...I$_i@@@@@rd   c                  L   t                      } t          t          | d                    }t          t          | d                    }t          |          t          |          k    sJ d fd|D             }fd|D             }|                    |          sJ d S )NTr  Fc                 J    	 | j         S # t          $ r | j        j         cY S w xY wro   )rg   r  func)r  s    rb   get_check_namez4test_yield_all_checks_legacy.<locals>.get_check_name`  s;    	'>! 	' 	' 	':&&&&	's   	 ""c                 &    h | ]} |          S rk   rk   r  r  r  s     rb   	<setcomp>z/test_yield_all_checks_legacy.<locals>.<setcomp>g  s#    SSSnnU33SSSrd   c                 &    h | ]} |          S rk   rk   r  s     rb   r  z/test_yield_all_checks_legacy.<locals>.<setcomp>h  s#    KKKE..//KKKrd   )r#   r  r+   r(  issubset)r  legacy_checksnon_legacy_checksnon_legacy_check_nameslegacy_check_namesr  s        @rb   test_yield_all_checks_legacyr  W  s    !##I*9TBBBCCM.yGGGHH}$5 6 66666' ' ' TSSSARSSSKKKK]KKK!**+=>>>>>>>rd   c                       G d dt                     }  |             }d}t          t          |          5  t          d|           ddd           dS # 1 swxY w Y   dS )zICheck that the right error is raised when the estimator is not cloneable.c                       e Zd Zd ZdS ):test_check_estimator_cloneable_error.<locals>.NotCloneablec                      t          d          )Nz This estimator is not cloneable.NotImplementedErrorr   s    rb   __sklearn_clone__zLtest_check_estimator_cloneable_error.<locals>.NotCloneable.__sklearn_clone__p  s    %&HIIIrd   N)rg   rh   ri   r  rk   rd   rb   NotCloneabler  o  s(        	J 	J 	J 	J 	Jrd   r  zCloning of .* failed with errorr  N)r   r(   r  r9   )r  r  r  s      rb   $test_check_estimator_cloneable_errorr   l  s    J J J J J} J J J I
+C	c	*	*	* = =!.)<<<= = = = = = = = = = = = = = = = = =   AAAc                       G d dt                     }  |             }d}t          t          |          5  t          d|           ddd           dS # 1 swxY w Y   dS )zMCheck that the right error is raised when the estimator does not have a repr.c                       e Zd Zd ZdS )*test_estimator_repr_error.<locals>.NotReprc                      t          d          )Nz$This estimator does not have a repr.r  r   s    rb   __repr__z3test_estimator_repr_error.<locals>.NotRepr.__repr__}  s    %&LMMMrd   N)rg   rh   ri   r&  rk   rd   rb   NotReprr$  |  s(        	N 	N 	N 	N 	Nrd   r'  zRepr of .* failed with errorr  N)r   r(   r  r:   )r'  r  r  s      rb   test_estimator_repr_errorr(  y  s    N N N N N- N N N 		I
(C	c	*	*	* 3 3Y	2223 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3r!  c                      G d d          }  G d d          } G d d          }d}t          t          |          5  t          d |                        d d d            n# 1 swxY w Y   t          t          |          5  t          d |                       d d d            n# 1 swxY w Y   t          d |                       d S )	Nc                       e Zd Zd ZdS )8test_check_estimator_tags_renamed.<locals>.BadEstimator1c                     d S ro   rk   r   s    rb   
_more_tagszCtest_check_estimator_tags_renamed.<locals>.BadEstimator1._more_tags      4rd   N)rg   rh   ri   r-  rk   rd   rb   BadEstimator1r+    #        	 	 	 	 	rd   r/  c                       e Zd Zd ZdS )8test_check_estimator_tags_renamed.<locals>.BadEstimator2c                     d S ro   rk   r   s    rb   	_get_tagszBtest_check_estimator_tags_renamed.<locals>.BadEstimator2._get_tags  r.  rd   N)rg   rh   ri   r4  rk   rd   rb   BadEstimator2r2    r0  rd   r5  c                       e Zd Zd Zd ZdS )8test_check_estimator_tags_renamed.<locals>.OkayEstimatorc                     d S ro   rk   r   s    rb   r`  zItest_check_estimator_tags_renamed.<locals>.OkayEstimator.__sklearn_tags__  r.  rd   c                     d S ro   rk   r   s    rb   r-  zCtest_check_estimator_tags_renamed.<locals>.OkayEstimator._more_tags  r.  rd   N)rg   rh   ri   r`  r-  rk   rd   rb   OkayEstimatorr7    s2        	 	 		 	 	 	 	rd   r:  z.has defined either `_more_tags` or `_get_tags`r  )r(   r  r>   )r/  r5  r:  r  s       rb   !test_check_estimator_tags_renamedr;    s                         ;C			%	%	% G G$_mmooFFFG G G G G G G G G G G G G G G			%	%	% G G$_mmooFFFG G G G G G G G G G G G G G G !--//BBBBBs$    A%%A),A)B++B/2B/c                       G d dt                     } d}t          t          |          5  t          d |                        ddd           dS # 1 swxY w Y   dS )zeCheck that when the estimator has the wrong tags.classifier_tags.multi_class
    set, the test fails.c                       e Zd Zd ZdS )Etest_check_classifier_not_supporting_multiclass.<locals>.BadEstimatorc                     | S ro   rk   rp   s      rb   rt   zItest_check_classifier_not_supporting_multiclass.<locals>.BadEstimator.fit  r,  rd   Nr   rk   rd   rb   BadEstimatorr>    s#        	 	 	 	 	rd   r@  z=The estimator tag `tags.classifier_tags.multi_class` is Falser  N)r   r(   r  r/   r@  r  s     rb   /test_check_classifier_not_supporting_multiclassrB    s        }    JC	c	*	*	* S S2><<>>RRRS S S S S S S S S S S S S S S S S Ss   AAAc                      dD ]n} 	 t          j        |            n!# t          $ r t          d|  d          w xY wt	                                          |           }t          |ddi           od S )N)r   polarszLibrary z is not installed)r  r,   z_this check is expected to fail because pandas and polars are not compatible with the array api.)r  r  )r  
__import__rJ  r&   r   
set_outputr8   )libr  s     rb   test_estimator_with_set_outputrH    s     $ 
 
	> %%%% 	> 	> 	><c<<<===	> #$$//#/>>	'>$	
 	
 	
 	
 	

 
s   9c                  ^    t          t                                } t          |           sJ dS )z0Check that checks_generator returns a generator.N)rP   r   r   )all_instance_gen_checkss    rb   test_estimator_checks_generatorrK    s2    89K9M9MNN.///////rd   c                      t          t          d          5  t          t                      dd            ddd           dS # 1 swxY w Y   dS )zMCheck that check_estimator fails correctly with on_fail='raise' and callback.z9callback cannot be provided together with on_fail='raise'r  raisec                      d S ro   rk   rk   rd   rb   r  zDtest_check_estimator_callback_with_fast_fail_error.<locals>.<lambda>  s    PT rd   )r  r  N)r(   r   r8   r   rk   rd   rb   2test_check_estimator_callback_with_fast_fail_errorrO    s    	U
 
 
 V V 	*,,gUUUUV V V V V V V V V V V V V V V V V Vs    AAAc                       G d dt           t                    } d}t          t          t	          j        |                    5  t          d |                        ddd           dS # 1 swxY w Y   dS )zFTest that the check raises an error when the mixin order is incorrect.c                       e Zd ZddZdS ),test_check_mixin_order.<locals>.BadEstimatorNc                     | S ro   rk   rp   s      rb   rt   z0test_check_mixin_order.<locals>.BadEstimator.fit  r,  rd   ro   r   rk   rd   rb   r@  rR    s(        	 	 	 	 	 	rd   r@  z8TransformerMixin comes before/left side of BaseEstimatorr  N)r   r   r(   r  reescaperF   rA  s     rb   test_check_mixin_orderrV    s        }&6    EC	binn	5	5	5 : :.,,..999: : : : : : : : : : : : : : : : : :s   A**A.1A.c                       G d dt                     } t          t          d          5  t          d |                        d d d            d S # 1 swxY w Y   d S )Nc                        e Zd Z fdZ xZS )Htest_check_positive_only_tag_during_fit.<locals>.RequiresPositiveXBadTagc                 `    t                                                      }d|j        _        |S r_  )r   r`  rm  rn  rc  s     rb   r`  zYtest_check_positive_only_tag_during_fit.<locals>.RequiresPositiveXBadTag.__sklearn_tags__  s'    77++--D,1DO)Krd   r  r   s   @rb   RequiresPositiveXBadTagrY    s8        	 	 	 	 	 	 	 	 	rd   r[  z5This happens when passing negative input values as X.r  )rg  r(   r  rK   )r[  s    rb   'test_check_positive_only_tag_during_fitr\    s        "<    
U
 
 
 
 
 	+%'>'>'@'@	
 	
 	

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
s   AAA)r  rT  r\   r  r  inspectr   numbersr   r   r  numpyry   scipy.sparsero  r   sklearnr   r   sklearn.baser   r	   r
   r   sklearn.clusterr   sklearn.datasetsr   r   sklearn.decompositionr   sklearn.exceptionsr   r   r   sklearn.linear_modelr   r   r   r   sklearn.mixturer   sklearn.neighborsr   r  r   sklearn.svmr   r   r  r   r   r   sklearn.utils._param_validationr   r    -sklearn.utils._test_common.instance_generatorr!   r"   sklearn.utils._testingr#   r$   r%   r&   r'   r(   sklearn.utils.estimator_checksr)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   sklearn.utils.fixesrR   rS   sklearn.utils.metaestimatorsrT   sklearn.utils.multiclassrU   sklearn.utils.validationrV   rW   rX   rY   rc   r   rf   rm   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r	  r  r  r  r/  r<  rE  rN  rW  rg  rq  rx  r~  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r	  r  r  r  r2  r7  r:  r=  rA  rC  rf  ru  r{  r  r  r  rg   r  r  r  r  r  r  r  r  r  r  r	  r  r   r(  r;  rB  rH  rK  rO  rV  r\  rk   rd   rb   <module>rs     s  
     				 



         " " " " " " " "            . . . . . . . . W W W W W W W W W W W W + + + + + +        & % % % % %         
            , + + + + + 1 1 1 1 1 1 0 0 0 0 0 0 " " " " " " " " @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @                      * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *V @ ? ? ? ? ? ? ? 5 5 5 5 5 5 3 3 3 3 3 3                 J   # # # # # # # ## # # # #- # # #           M              ]   "    =   	 	 	 	 	] 	 	 	       "    =   &    (   # # # # #* # # #(	# 	# 	# 	# 	#&7 	# 	# 	## # # # #] # # #(    #4   ,       $ $ $ $ $- $ $ $     m   *"# "# "# "# "#$5 "# "# "#J               F( ( ( ( ((- ( ( ("4 4 4 4 4] 4 4 4,    }       5   "    !1    
 
 
 
 
!1 
 
 
    "4   	 	 	 	 	= 	 	 	' ' ' ' '] ' ' '
 
 
0 0 0	L 	L 	L, , ,R R R (9 9 ('9I I I4 4 4  "L L L	F 	F 	F
 
 
V V V  <
 
 
E E E< (!3 !3 ('!3H- - -,P ,P ,P^6 6 6, , ,D	N 	N 	N.
 .
 .
h (
R 
R ('
R
 
 

 
 
L L L 
 
 
 
 
O] 
 
 
(X (X (XVy
 y
 y
x2
 2
 2
j  
 
 
 (: : (': z 1 1 1.F F F@ (? ? ('?( (7 7 ('70" " "N# # #L L L2F F FB@ @ @&3O 3O 3OlA A A? ? ?*
= 
= 
=
3 
3 
3C C C8S S S  (
 
 ('
(0 0 0V V V	: 	: 	:
 
 
 
 
rd   