
    Q3j                        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 Zxd Zy G d dez      Z{ 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 d0 d1e|      Z G d2 d3e|      Z G d4 d5e|      Z G d6 d7e      Z G d8 d9e|      Z G d: d;e      Z G d< d=e      Z G d> d?e      Z G d@ dAe|      Z G dB dCe      Z G dD dEee      Z G dF dGe      Z G dH dIe'      Z G dJ dKe      Z G dL dMe$      Z G dN dOe$      Z G dP dQe%      Z G dR dSe      Z G dT dUe      ZdV ZdW ZdX ZdY ZdZ Zexd[        Zd\ Zd] Zd^ Zd_ Zd` Zda Zdb Zdc Zdd Zde Zeyexdf               Zdg Zdh Zdi Zeydj        Zdk Zdl Zexdm        Zdn Zdo Zdp Z G dq dree      Zds Zdt Zdu Zdv Zdw Zexdx        Zedyk(  r e        dz Zd{ Zexd|        Zexd}        Zd~ Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zexd        Zd Zd Zd Zd Zy)    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                  j                  d      }||j                  j	                  |       S | S Npytest)sysmodulesgetmarkthread_unsafefr\   s     V/DATA/.local/lib/python3.12/site-packages/sklearn/utils/tests/test_estimator_checks.py&_mark_thread_unsafe_if_pytest_importedre   l   s4    [[__X&F{{((++    c                 t    t         j                  j                  d      }||j                  j                  S | S r[   )r]   r^   r_   r`   no_check_spmatrixrb   s     rd   *_mark_no_check_spmatrix_if_pytest_importedri   t   s/    [[__X&F{{,,,rf   c                       e Zd ZdZy)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__ rf   rd   rk   rk   |   s    rf   rk   c                       e Zd Zd Zd Zy)BaseBadClassifierc                     | S Nrp   selfXys      rd   fitzBaseBadClassifier.fit       rf   c                 F    t        j                  |j                  d         S Nr   nponesshaperv   rw   s     rd   predictzBaseBadClassifier.predict   s    wwqwwqz""rf   Nrl   rm   rn   ry   r   rp   rf   rd   rr   rr      s    #rf   rr   c                   "    e Zd ZddZddZd Zy)ChangesDictc                     || _         y rt   )key)rv   r   s     rd   __init__zChangesDict.__init__   s	    rf   Nc                 &    t        | ||      \  }}| S rt   rY   ru   s      rd   ry   zChangesDict.fit       T1a(1rf   c                 j    t        |      }d| _        t        j                  |j                  d         S )Ni  r   )rV   r   r~   r   r   r   s     rd   r   zChangesDict.predict   s)    Nwwqwwqz""rf   r   rt   rl   rm   rn   r   ry   r   rp   rf   rd   r   r      s    #rf   r   c                       e Zd ZddZddZy)SetsWrongAttributec                     || _         y rt   )acceptable_key)rv   r   s     rd   r   zSetsWrongAttribute.__init__   s
    ,rf   Nc                 4    d| _         t        | ||      \  }}| S r|   wrong_attributerY   ru   s      rd   ry   zSetsWrongAttribute.fit   !     T1a(1rf   r   rt   rl   rm   rn   r   ry   rp   rf   rd   r   r      s    -rf   r   c                       e Zd ZddZddZy)ChangesWrongAttributec                     || _         y rt   )r   )rv   r   s     rd   r   zChangesWrongAttribute.__init__   
    .rf   Nc                 4    d| _         t        | ||      \  }}| S N   r   ru   s      rd   ry   zChangesWrongAttribute.fit   r   rf   r   rt   r   rp   rf   rd   r   r      s    /rf   r   c                       e Zd ZddZy)ChangesUnderscoreAttributeNc                 4    d| _         t        | ||      \  }}| S r   )_good_attributerY   ru   s      rd   ry   zChangesUnderscoreAttribute.fit   r   rf   rt   rl   rm   rn   ry   rp   rf   rd   r   r      s    rf   r   c                   .     e Zd ZddZ fdZddZ xZS )RaisesErrorInSetParamsc                     || _         y rt   prv   r   s     rd   r   zRaisesErrorInSetParams.__init__   	    rf   c                 z    d|v r(|j                  d      }|dk  rt        d      || _        t        |   di |S )Nr   r   zp can't be less than 0rp   )pop
ValueErrorr   super
set_paramsrv   kwargsr   	__class__s      rd   r   z!RaisesErrorInSetParams.set_params   sD    &=

3A1u !9::DFw!+F++rf   c                 &    t        | ||      \  }}| S rt   r   ru   s      rd   ry   zRaisesErrorInSetParams.fit   r   rf   r   rt   rl   rm   rn   r   r   ry   __classcell__r   s   @rd   r   r          ,rf   r   c                   (    e Zd Z e       fdZddZy)HasMutableParametersc                     || _         y rt   r   r   s     rd   r   zHasMutableParameters.__init__   r   rf   Nc                 &    t        | ||      \  }}| S rt   r   ru   s      rd   ry   zHasMutableParameters.fit   r   rf   rt   )rl   rm   rn   objectr   ry   rp   rf   rd   r   r      s     rf   r   c                   B    e Zd Zd ej                  d      efdZddZy)HasImmutableParameters*   c                 .    || _         || _        || _        y rt   )r   qr)rv   r   r   r   s       rd   r   zHasImmutableParameters.__init__   s    rf   Nc                 &    t        | ||      \  }}| S rt   r   ru   s      rd   ry   zHasImmutableParameters.fit   r   rf   rt   )rl   rm   rn   r~   int32r   r   ry   rp   rf   rd   r   r      s    xrxx|v 
rf   r   c                   .     e Zd ZddZ fdZddZ xZS )"ModifiesValueInsteadOfRaisingErrorc                     || _         y rt   r   r   s     rd   r   z+ModifiesValueInsteadOfRaisingError.__init__   r   rf   c                 h    d|v r|j                  d      }|dk  rd}|| _        t        |   di |S )Nr   r   rp   )r   r   r   r   r   s      rd   r   z-ModifiesValueInsteadOfRaisingError.set_params   s=    &=

3A1uDFw!+F++rf   c                 &    t        | ||      \  }}| S rt   r   ru   s      rd   ry   z&ModifiesValueInsteadOfRaisingError.fit   r   rf   r   rt   r   r   s   @rd   r   r      r   rf   r   c                   .     e Zd ZddZ fdZddZ xZS )ModifiesAnotherValuec                      || _         || _        y rt   )ab)rv   r   r   s      rd   r   zModifiesAnotherValue.__init__   s    rf   c                     d|v r2|j                  d      }|| _        ||j                  d       d| _        t        |   di |S )Nr   r   method2rp   )r   r   r   r   r   )rv   r   r   r   s      rd   r   zModifiesAnotherValue.set_params   sH    &=

3ADFy

3"w!+F++rf   c                 &    t        | ||      \  }}| S rt   r   ru   s      rd   ry   zModifiesAnotherValue.fit   r   rf   )r   method1rt   r   r   s   @rd   r   r      s    ,rf   r   c                       e Zd Zd Zy)NoCheckinPredictc                 &    t        | ||      \  }}| S rt   r   ru   s      rd   ry   zNoCheckinPredict.fit   r   rf   Nr   rp   rf   rd   r   r      s    rf   r   c                        e Zd ZddZd Zd Zy)NoSparseClassifierNc                     || _         y rt   raise_for_typerv   r   s     rd   r   zNoSparseClassifier.__init__  
    ,rf   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   rv   rw   rx   correct_types       rd   ry   zNoSparseClassifier.fit
  sj    T1au~F1.0%a4L  O3%a5L011rf   c                 \    t        |      }t        j                  |j                  d         S r|   rV   r~   r   r   r   s     rd   r   zNoSparseClassifier.predict  "    Nwwqwwqz""rf   rt   r   rp   rf   rd   r   r     s    -#rf   r   c                       e Zd Zd Zd Zy)CorrectNotFittedErrorClassifierc                 t    t        | ||      \  }}t        j                  |j                  d         | _        | S r   )rY   r~   r   r   coef_ru   s      rd   ry   z#CorrectNotFittedErrorClassifier.fit  s1    T1a(1WWQWWQZ(
rf   c                 r    t        |        t        |      }t        j                  |j                  d         S r|   )rW   rV   r~   r   r   r   s     rd   r   z'CorrectNotFittedErrorClassifier.predict  s*    Nwwqwwqz""rf   Nr   rp   rf   rd   r   r     s    
#rf   r   c                       e Zd ZddZd Zy)NoSampleWeightPandasSeriesTypeNc                 h    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   )rv   rw   rx   sample_weightr   s        rd   ry   z"NoSampleWeightPandasSeriesType.fit&  sD    !Qn4SW
1 	"mV,P  rf   c                 \    t        |      }t        j                  |j                  d         S r|   r   r   s     rd   r   z&NoSampleWeightPandasSeriesType.predict4  r   rf   rt   r   rp   rf   rd   r   r   %  s    #rf   r   c                       e Zd ZddZd Zy)BadBalancedWeightsClassifierNc                     || _         y rt   )class_weight)rv   r  s     rd   r   z%BadBalancedWeightsClassifier.__init__:  s
    (rf   c                     ddl m} ddlm}  |       j	                  |      }|j
                  } || j                  ||      }| j                  dk(  r|dz  }|| _        | S )Nr   )LabelEncoder)compute_class_weight)classesrx   balanced      ?)sklearn.preprocessingr  sklearn.utilsr  ry   classes_r  r   )rv   rw   rx   r  r  label_encoderr  r  s           rd   ry   z BadBalancedWeightsClassifier.fit=  sb    66$**1-((+D,=,=wRST 
*CL "
rf   rt   r   rp   rf   rd   r   r   9  s    )rf   r   c                       e Zd ZddZd Zy)BadTransformerWithoutMixinNc                     t        | |      }| S rt   r   ru   s      rd   ry   zBadTransformerWithoutMixin.fitP  s    $"rf   c                 8    t        |        t        | |d      }|S )NFreset)rW   rY   r   s     rd   	transformz$BadTransformerWithoutMixin.transformT  s    $/rf   rt   )rl   rm   rn   ry   r  rp   rf   rd   r  r  O  s    rf   r  c                       e Zd Zd Zd Zy)NotInvariantPredictc                 .    t        | ||ddd      \  }}| S Nr   Tr   r   ru   s      rd   ry   zNotInvariantPredict.fit[  s%    !Qn4SW
1 rf   c                     t        |      }|j                  d   dkD  r"t        j                  |j                  d         S t        j                  |j                  d         S )Nr   r   )rV   r   r~   r   zerosr   s     rd   r   zNotInvariantPredict.predictb  sH    N771:>771771:&&xx
##rf   Nr   rp   rf   rd   r  r  Z  s    $rf   r  c                       e Zd Zd Zd Zy)NotInvariantSampleOrderc                 <    t        | ||ddd      \  }}|| _        | S r  )rY   _Xru   s      rd   ry   zNotInvariantSampleOrder.fitk  s,    !Qn4SW
1 rf   c                 <   t        |      }t        j                  t        j                  |d      t        j                  | j                  d            r?|| j                  k7  j                         r"t        j                  |j                  d         S |d d df   S )Nr   )axis)rV   r~   array_equivsortr  anyr  r   r   s     rd   r   zNotInvariantSampleOrder.predicts  sm    N NN27711-rwwtwwQ/GHdgg""$88AGGAJ''Awrf   Nr   rp   rf   rd   r  r  j  s    	rf   r  c                   &    e Zd ZdZddZddZd Zy)OneClassSampleErrorClassifierzoClassifier allowing to trigger different behaviors when `sample_weight` reduces
    the number of classes to 1.c                     || _         y rt   )raise_when_single_class)rv   r&  s     rd   r   z&OneClassSampleErrorClassifier.__init__  s
    '>$rf   Nc                    t        ||ddd      \  }}d| _        t        j                  |d      \  | _        }| j                  j
                  d   }|dk  r| j                  rd| _        t        d      |ht        |t        j                        r7t        |      dkD  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_r~   uniquer  r   r&  r   r   ndarraylencount_nonzerobincount)rv   rw   rx   r   
n_classes_s        rd   ry   z!OneClassSampleErrorClassifier.fit  s    qTT
1 "'99Qt<q]]((+
>d::%)D"122 $-4]9Ka9O--bkk!].KL
A~)-& !455rf   c                     t        |        t        |      }| j                  r"t        j                  |j
                  d         S t        j                  |j
                  d         S r|   )rW   rV   r*  r~   r  r   r   r   s     rd   r   z%OneClassSampleErrorClassifier.predict  sJ    N!!88AGGAJ''wwqwwqz""rf   )Frt   rl   rm   rn   ro   r   ry   r   rp   rf   rd   r$  r$    s    #?,#rf   r$  c                       e Zd ZdZddZd Zy)!LargeSparseNotSupportedClassifierz^Estimator that claims to support large sparse data
    (accept_large_sparse=True), but doesn'tNc                     || _         y rt   r   r   s     rd   r   z*LargeSparseNotSupportedClassifier.__init__  r   rf   c           	         t        | ||dddd      \  }}| j                  dk(  rt        |t        j                        }n)| j                  dk(  rt        |t        j
                        }r|j                  dk(  r?|j                  j                  dk(  s|j                  j                  dk(  rt        d      | S |j                  d	v r5d|j                  j                  |j                  j                  fvsJ d       | S )
N)r   r   cooT)r   accept_large_sparser   r   r   r   r7  int64z(Estimator doesn't support 64-bit indices)r   r   )rY   r   r   r   r   r   formatrowdtypecolr   indicesindptrr   s       rd   ry   z%LargeSparseNotSupportedClassifier.fit  s    / $
1 .0%a4L  O3%a5Lxx5 55;;')QUU[[G-C$%OPP  ^+IIOOHHNN'  > >> 
 rf   rt   )rl   rm   rn   ro   r   ry   rp   rf   rd   r4  r4    s    /-rf   r4  c                   *    e Zd ZddZddZddZd Zy)SparseTransformerNc                     || _         y rt   sparse_container)rv   rD  s     rd   r   zSparseTransformer.__init__  s
     0rf   c                     t        | |       | S rt   r   ru   s      rd   ry   zSparseTransformer.fit  s    dArf   c                 D    | j                  ||      j                  |      S rt   )ry   r  ru   s      rd   fit_transformzSparseTransformer.fit_transform  s    xx1~''**rf   c                 X    t        |        t        | |dd      }| j                  |      S )NTF)r   r  )rW   rY   rD  r   s     rd   r  zSparseTransformer.transform  s+    $UC$$Q''rf   rt   )rl   rm   rn   r   ry   rG  r  rp   rf   rd   rA  rA    s    1+(rf   rA  c                       e Zd Zd Zd Zy)EstimatorInconsistentForPandasc                     	 ddl m} t        ||      r|j                  d   | _        | S t        |      }|d   | _        | S # t        $ r t        |      }|d   | _        | cY S w xY w)Nr   )	DataFrame)r   r   )r   r   )r   rL  r   ilocvalue_rV   ImportError)rv   rw   rx   rL  s       rd   ry   z"EstimatorInconsistentForPandas.fit  sm    	(!Y'ffTl K  NgK 	AAD'DKK	s   'A A  A$#A$c                 x    t        |      }t        j                  | j                  g|j                  d   z        S r|   )rV   r~   arrayrN  r   r   s     rd   r   z&EstimatorInconsistentForPandas.predict  s-    Nxx
233rf   Nr   rp   rf   rd   rJ  rJ    s     4rf   rJ  c                   ,     e Zd Zd fd	Zd fd	Z xZS )UntaggedBinaryClassifierc                 t    t         |   |||||       t        | j                        dkD  rt	        d      | S )Nr)  Only 2 classes are supported)r   ry   r-  r  r   )rv   rw   rx   	coef_initintercept_initr   r   s         rd   ry   zUntaggedBinaryClassifier.fit  s9    Aq)^]Ct}}!;<<rf   c                 t    t         |   ||||       t        | j                        dkD  rt	        d      | S )N)rw   rx   r  r   r)  rU  )r   partial_fitr-  r  r   )rv   rw   rx   r  r   r   s        rd   rY  z$UntaggedBinaryClassifier.partial_fit  s;    a1g]St}}!;<<rf   )NNNNN)rl   rm   rn   ry   rY  r   r   s   @rd   rS  rS    s     rf   rS  c                   (     e Zd Z fdZ fdZ xZS )TaggedBinaryClassifierc                 h    t        |dd      }|dk7  rt        d| d      t        |   ||      S )Nrx   T)
input_nameraise_unknownbinaryzCOnly binary classification is supported. The type of the target is .)rU   r   r   ry   )rv   rw   rx   y_typer   s       rd   ry   zTaggedBinaryClassifier.fit  sJ    cFXXQ   w{1a  rf   c                 F    t         |          }d|j                  _        |S NF)r   __sklearn_tags__classifier_tagsmulti_classrv   tagsr   s     rd   re  z'TaggedBinaryClassifier.__sklearn_tags__  s#    w')+0(rf   rl   rm   rn   ry   re  r   r   s   @rd   r\  r\    s    ! rf   r\  c                   (     e Zd Z fdZ fdZ xZS )RequiresPositiveXRegressorc                     t        | ||dd      \  }}|dk  j                         rt        d      t        |   ||      S )NFTr   r   r   z$Negative values in data passed to X.rY   r"  r   r   ry   rv   rw   rx   r   s      rd   ry   zRequiresPositiveXRegressor.fit  sC    T1au4P1E;;=CDDw{1a  rf   c                 h    t         |          }d|j                  _        d|j                  _        |S )NTF)r   re  
input_tagspositive_onlysparserh  s     rd   re  z+RequiresPositiveXRegressor.__sklearn_tags__  s-    w')(,%!&rf   rj  r   s   @rd   rl  rl    s    ! rf   rl  c                   (     e Zd Z fdZ fdZ xZS )RequiresPositiveYRegressorc                     t        | ||dd      \  }}|dk  j                         rt        d      t        |   ||      S )NTrn  r    negative y values not supported!ro  rp  s      rd   ry   zRequiresPositiveYRegressor.fit  sC    T1at$O1F<<>?@@w{1a  rf   c                 F    t         |          }d|j                  _        |S NT)r   re  target_tagsrs  rh  s     rd   re  z+RequiresPositiveYRegressor.__sklearn_tags__%  s#    w'))-&rf   rj  r   s   @rd   rv  rv    s    ! rf   rv  c                   (     e Zd Z fdZ fdZ xZS )PoorScoreLogisticRegressionc                 (    t         |   |      dz   S r   )r   decision_function)rv   rw   r   s     rd   r  z-PoorScoreLogisticRegression.decision_function,  s    w(+a//rf   c                 F    t         |          }d|j                  _        |S rz  )r   re  rf  
poor_scorerh  s     rd   re  z,PoorScoreLogisticRegression.__sklearn_tags__/  s#    w')*.'rf   )rl   rm   rn   r  re  r   r   s   @rd   r}  r}  +  s    0 rf   r}  c                       e Zd Zd Zd Zy)PartialFitChecksNamec                      t        | ||       | S rt   r   ru   s      rd   ry   zPartialFitChecksName.fit6  s    dAq!rf   c                 L    t        | d       }t        | |||       d| _        | S )N_fittedr  T)hasattrrY   r  )rv   rw   rx   r  s       rd   rY  z PartialFitChecksName.partial_fit:  s+    D),,dAq.rf   N)rl   rm   rn   ry   rY  rp   rf   rd   r  r  5  s    rf   r  c                       e Zd ZdZd Zd Zy)BrokenArrayAPIz=Make different predictions when using Numpy and the Array APIc                     | S rt   rp   ru   s      rd   ry   zBrokenArrayAPI.fitD  rz   rf   c                     t               d   }t        j                  |      \  }}|r|j                  g d      S t	        j
                  g d      S )Narray_api_dispatch)r   r)     )r  r)  r   )r   r   get_namespaceasarrayr~   rQ  )rv   rw   enabledxp_s        rd   r   zBrokenArrayAPI.predictG  sD    ,34((+A::i((88I&&rf   N)rl   rm   rn   ro   ry   r   rp   rf   rd   r  r  A  s    G'rf   r  c                      	 t        j                  d       t	        t
        d      5  t        dt               dd       d d d        y # t        $ r t        d      w xY w# 1 sw Y   y xY w)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  rp   rf   rd   test_check_array_api_inputr  P  sm    H 23 
&>	?.		
 
@	?  HFGGH 
@	?s   A	 A!	A!A*c                      t        t        j                  d            } d}t        t        |      5  t        j
                  |        d d d        t        j                  | d       sJ y # 1 sw Y   "xY w)N
   z&Don't want to call array_function sum!r  )r*   r~   r   r(   	TypeErrorsummay_share_memory)	not_arraymsgs     rd    test_not_an_array_array_functionr  _  sU    BGGBK(I
2C			%
y 
& y$/// 
&	%s   A))A2c                  D     G d dt               } t        d |               y )Nc                   (    e Zd Z ed      d        Zy)btest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethodz=Deprecated for the purpose of testing check_fit_score_takes_yc                     | S rt   rp   ru   s      rd   ry   zftest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethod.fitm  s    Krf   N)rl   rm   rn   r   ry   rp   rf   rd   $TestEstimatorWithDeprecatedFitMethodr  l  s    	S	T	 
U	rf   r  test)r   rC   )r  s    rd   4test_check_fit_score_takes_y_works_on_deprecated_fitr  h  s    } 
 F$H$JKrf   c                  r    d} t        t        |       5  t        t               ddd       y# 1 sw Y   yxY w)z7Test that passing a class instead of an instance fails.zPassing a class was deprecatedr  N)r(   r  r8   r   r  s    rd   'test_check_estimator_with_class_removedr  t  s&    
*C			%*+ 
&	%	%s   -6c                      d} t        dt                      t        t        |       5  t        dt	                      ddd       y# 1 sw Y   yxY w)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    rd   test_mutable_default_paramsr  {  sE    	& 
 ++- 
c	*.y:N:PQ 
+	*	*s   AAc                     d} t        t        |       5  t        dt                      ddd       t	        j
                  d      5 }t        dt                      ddd       t        D cg c]  }|j                   c}v sJ t        t        |       5  t        dt                      ddd       y# 1 sw Y   xY w# 1 sw Y   fxY wc c}w # 1 sw Y   yxY w)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record)
r(   r  rO   r   warningscatch_warningsr   UserWarningcategoryr   )r  recordsrecs      rd   test_check_set_paramsr    s     KC	c	*!C!EF 
+ 
	 	 	-!7!9: 
.7;7C3<<7;;;;	c	*!5!78 
+	* 
+	* 
.	-;	*	*s)   B5C-CC5B>C
Cc                  |    d} t        t        |       5  t        dt                      d d d        y # 1 sw Y   y xY w)NzCEstimator NoCheckinPredict doesn't check for NaN and inf in predictr  r   )r(   r  r?   r   r  s    rd   test_check_estimators_nan_infr    s,    
OC	c	* !35E5GH 
+	*	*   2;c                  |    d} t        t        |       5  t        dt                      d d d        y # 1 sw Y   y xY w)Nz)Estimator changes __dict__ during predictr  r  )r(   r  r6   r   r  s    rd   test_check_dict_unchangedr    s+     6C	c	*V[]3 
+	*	*r  c                      	 ddl m}  d}t        t        |      5  t	        dt                      d d d        y # 1 sw Y   y xY w# t        $ r Y y 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   rO  )r   r  s     rd   'test_check_sample_weights_pandas_seriesr    sQ    !A 	 Jc*.02P2R +**  s*   A 9A AA A 	AAc                      d} t        t        |       5  t        dt                      d d d        t        dt	                      y # 1 sw Y   xY w)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    rd   &test_check_estimators_overwrite_paramsr    sH    	@  
c	*)#%:%<	
 
+ &f.H.JK	 
+	*   AAc                  |    d} t        t        |       5  t        dt                      d d d        y # 1 sw Y   y xY w)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    rd   $test_check_dont_overwrite_parametersr    s2    	,  
c	*'0B0DE 
+	*	*r  c                      t         j                  } d}dj                  ||       }t        t        |      5  t        dt                      d d d        y # 1 sw Y   y xY w)Nr   zY{method} of {name} is not invariant when applied to a datasetwith different sample order.methodnamer  r  )r  rl   r:  r(   r  rD   r  r  r  s      rd   *test_check_methods_sample_order_invariancer    sS    "++DF	'fFf&  
c	*-%'>'@	
 
+	*	*   AAc                      t         j                  } d}dj                  ||       }t        t        |      5  t        dt                      d d d        y # 1 sw Y   y xY w)Nr   z={method} of {name} is not invariant when applied to a subset.r  r  r  )r  rl   r:  r(   r  rE   r  s      rd   $test_check_methods_subset_invariancer    sT    ''DFJ
R
RD S C 
c	*'(=?R?TU 
+	*	*r  c                  $   t         j                  } d| z  }t        t        |      5  t	        | t        d             d d d        t
        r/t        t        |      5  t        | t        d             d d d        d}t        t        |      5  t	        dt        d             d d d        t
        r0t        t        |      5  t        dt        d             d d d        y y # 1 sw Y   xY w# 1 sw Y   }xY w# 1 sw Y   XxY w# 1 sw Y   y xY w)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.*r4  )r   rl   r(   r  r<   rS   r;   r4  r  r  s     rd    test_check_estimator_sparse_datar    s    &&D
G$
NC	c	*%d,>,OP 
+ N#.(/A./QR /
	D  
c	*%/-o>	
 
+ N#.(31.A /. % 
+	* /. 
+	* /.s/   C"C.C:D"C+.C7:DDc                      t         j                  } |  d}t        t        |      5  t	        dt                      d d d        y # 1 sw Y   y xY w)Nzu failed when fitted on one label after sample_weight trimming. Error message is not explicit, it should have 'class'.r  r$  )r$  rl   r(   r  r3   r  s     rd   /test_check_classifiers_one_label_sample_weightsr  
  sJ    (11D&  	 
 
c	*2+-J-L	
 
+	*	*s   AAc                      t        t               d      } t        | t              sJ t	        |       dkD  sJ t        d | D              sJ t        d | D              sJ t        d | D              sJ y)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   | ]4  }t        |t              xr t        |j                               h d k(   6 yw)>   status	estimator	exception
check_nameexpected_to_failexpected_to_fail_reasonN)r   dictsetkeys.0items     rd   	<genexpr>z5test_check_estimator_not_fail_fast.<locals>.<genexpr>!  sE       "D 	4 		
		

		
 "s   :<c              3   ,   K   | ]  }|d    dk(    yw)r  failedNrp   r  s     rd   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>/       DmdtH~)m   c              3   ,   K   | ]  }|d    dk(    yw)r  passedNrp   r  s     rd   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>0  r  r  )r8   r   r   listr-  allr"  )check_resultss    rd   "test_check_estimator_not_fail_fastr    s     $MOTBMmT***}!!!  "    DmDDDDDmDDDDrf   c                     d} t        t        |       5  t        t                      d d d        d} t        t        |       5  t        t                      d d d        t        D ]  }t        t        |              t        t                      t        t        d             t        t                      t        t                      t        t                      d} t        t        |       5  t        t                      d d d        t        t                      y # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   5xY w)Nzobject has no attribute 'fit'r  rU  rC  g{Gz?)Crx  )r(   AttributeErrorr8   r   r   rS  rR   rA  r   r   r\  rl  rv  r}  )r  csr_containers     rd   test_check_estimatorr  3  s     *C	c	*( 
+ )C	
#	&023 
' ()=IJ (
 &()&./')* *,-.01 -C	
#	&245 
' /127 
+	*
 
'	&$ 
'	&s#   D#D/3D;#D,/D8;Ec                      t        j                  g d      } t        t              5  t	        dd|        d d d        t        j                  g d      } t	        dd|        y # 1 sw Y   .xY w)N)        r  g      ?       @r   r)  )r  r  r  r  )r~   rQ  r(   r  rI   )decisions    rd   test_check_outlier_corruptionr  \  sP    xx,-H		 Ax0 
  xx,-HQ8,	 
 	s   A""A+c                  .    G d dt               } ddddddddddt        dddt        dg}|D ]n  } | |d   |d         }|d	   !t        |j                  j                  |       8t        |d	         5  t        |j                  j                  |       ddd       p t        d
      t        d      fD ]D  } | dd|      }t        t              5  t        |j                  j                  |       ddd       F y# 1 sw Y   xY w# 1 sw Y   ]xY w)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>.EstimatorWithSparseConfigc                 .    || _         || _        || _        y rt   )
tag_sparser   	fit_error)rv   r  r   r  s       rd   r   zKtest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.__init__k  s    (DO!.D&DNrf   c                 h    | j                   r| j                   t        | ||| j                         | S )Nr   )r  rY   r   ru   s      rd   ry   zFtest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.fitp  s,    ~~nn$$1D4F4FGKrf   c                 Z    t         |          }| j                  |j                  _        |S rt   )r   re  r  rr  rt  rh  s     rd   re  zStest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.__sklearn_tags__v  s%    7+-D%)__DOO"Krf   rt   rl   rm   rn   r   ry   re  r   r   s   @rd   EstimatorWithSparseConfigr  j  s    	'
		 	rf   r  TN)r  r   
error_typeFr  r   r  zunexpected errorzother error)r   r  r=   r   rl   r(   r  KeyError)r  
test_cases	test_caser  r  s        rd   test_check_estimator_sparse_tagr  f  s   M $ d$GuDIt>Re>R	J  	-l#o&
	 \"*&y':':'C'CYO	,/0*9+>+>+G+GS 10     23Xm5LM	-eUIF	N#&y':':'C'CYO $# N 10 $#s   6!C?!D?D	D	c                  t    t        t        d      5  t        t                      d d d        y # 1 sw Y   y xY w)Nz%the `transformer_tags` tag is not set)r(   RuntimeErrorr8   r  rp   rf   rd   )test_check_estimator_transformer_no_mixinr    s(     
E	F245 
G	F	Fs   .7c                     t               } t        t        t        t        t
        fD ]	  }t        t              5   |       }t        |       t        j                  |      }t        |t        |             d d d        t        j                        k(  sJ t        t              5   |       }t        |       |j                  | j                  | j                         t        j                  |      }t        |t        |             d d d        |t        j                  |      k(  r
J  y # 1 sw Y   xY w# 1 sw Y   3xY w)N)r  expected_failed_checks)r   r   r   r   r   r   r'   r   rQ   joblibhashr8   r"   ry   datatarget)iris	Estimatorestold_hashs       rd   test_check_estimator_clonesr    s    ;D 		 &89+CS!{{3'H,G,L	 : 6;;s++++ &89+CS!GGDIIt{{+{{3'H,G,L : 6;;s++++5 :9 :9s   >D4*A$E 4D=	 E		c                      d} t        t        |       5  t        dt                      d d d        t        dt	                      y # 1 sw Y   xY w)Nz4Estimator should raise a NotFittedError when callingr  r  )r(   r  rA   r   r   r  s    rd   test_check_estimators_unfittedr    s@     AC	c	*!+/A/CD 
+
 k+J+LM 
+	*r  c                      G d dt               }  G d dt               } G d dt               }d}t        t        |      5  t        d	 |               d d d        d
}t        t        |      5  t        d	 |              d d d        t        d	 |              t        d      5  t        d	 |       j                  d             d d d        y # 1 sw Y   ~xY w# 1 sw Y   ]xY w# 1 sw Y   y xY w)Nc                       e Zd Zd Zy)Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSetc                     d | _         y rt   )you_should_not_set_this_rv   s    rd   r   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSet.__init__  s
    ,0D)rf   Nrl   rm   rn   r   rp   rf   rd    NonConformantEstimatorPrivateSetr    s    	1rf   r$  c                       e Zd ZddZy)Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSetNc                      y rt   rp   )rv   you_should_set_this_s     rd   r   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSet.__init__  s    rf   rt   r#  rp   rf   rd    NonConformantEstimatorNoParamSetr&    s    	rf   r)  c                       e Zd ZddiZddZy)Otest_check_no_attributes_set_in_init.<locals>.ConformantEstimatorClassAttributefooTNc                     | S rt   rp   ru   s      rd   ry   zStest_check_no_attributes_set_in_init.<locals>.ConformantEstimatorClassAttribute.fit      Krf   rt   )rl   rm   rn   9_ConformantEstimatorClassAttribute__metadata_request__fitry   rp   rf   rd   !ConformantEstimatorClassAttributer+    s    #($-	rf   r0  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)  r0  r  s       rd   $test_check_no_attributes_set_in_initr4    s    1= 1= M 	= 
 
c	*'>@	
 
+	  
c	*'>@	
 
+ $;= 
	5'-/??D?I	
 
6	5+ 
+	* 
+	* 
6	5s$   C.C%"C(CC%(C1c                  v    t        d      } t        |        t        d      } t        | t        |              y )Nprecomputed)kernel)metricr  )r   r8   r   r"   )r  s    rd   test_check_estimator_pairwiser9    s2     ]
#CC ]
3CC0KC0PQrf   c                  x    t        t        d      5  t        dt                      d d d        y # 1 sw Y   y xY wNr  r  r1  )r(   r  r.   rJ  rp   rf   rd   'test_check_classifier_data_not_an_arrayr<    s+    	&>	?*<>	
 
@	?	?   09c                  x    t        t        d      5  t        dt                      d d d        y # 1 sw Y   y xY wr;  )r(   r  rL   rJ  rp   rf   rd   &test_check_regressor_data_not_an_arrayr?    s+    	&>	?)<>	
 
@	?	?r=  c                     d} t        t        |       5  t        dt                      d d d        t        dt	                      t               }t        |j                  j                  |       d|_        d} t        t        |       5  t        |j                  j                  |       d d d        y # 1 sw Y   xY w# 1 sw Y   y xY w)Nz+Estimator does not have a feature_names_in_r  r1  z;Docstring that does not document the estimator's attributeszNEstimator LogisticRegression does not document its feature_names_in_ attribute)	r(   r   r4   rr   r  r   r   rl   ro   )err_msglrs     rd   -test_check_dataframe_column_names_consistencyrC    s    ;G	
'	*01ACTCVW 
+,-=?S?UV		B,R\\-B-BBGNBJX  

'	*01F1FK 
+	* 
+	* 
+	*s   B3	!B?3B<?Cc                   *     e Zd Zd Zd Z fdZ xZS )_BaseMultiLabelClassifierMockc                     || _         y rt   response_output)rv   rH  s     rd   r   z&_BaseMultiLabelClassifierMock.__init__,  r   rf   c                     | S rt   rp   ru   s      rd   ry   z!_BaseMultiLabelClassifierMock.fit/  rz   rf   c                 F    t         |          }d|j                  _        |S rz  )r   re  rf  multi_labelrh  s     rd   re  z._BaseMultiLabelClassifierMock.__sklearn_tags__2  s#    w')+/(rf   r  r   s   @rd   rE  rE  +  s    / rf   rE  c            	         d\  } }}t        | d|dddd      \  }}|| d  } G d d	t              } ||j                         
      }d}t        t        |      5  t        |j                  j                  |       d d d         ||d d d df   
      }d}t        t        |      5  t        |j                  j                  |       d d d         ||j                  t        j                        
      }d}t        t        |      5  t        |j                  j                  |       d d d        y # 1 sw Y   xY w# 1 sw Y   xxY w# 1 sw Y   y xY w)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y)\test_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredictc                     | j                   S rt   rG  r   s     rd   r   zdtest_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredict.predictF      '''rf   N)rl   rm   rn   r   rp   rf   rd   MultiLabelClassifierPredictr[  E      	(rf   r^  rG  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   rE  tolistr(   r  r1   r   rl   astyper~   float64)	rS  	test_size	n_outputsr  rx   y_testr^  clfrA  s	            rd   7test_check_classifiers_multilabel_output_format_predictrh  8  s>   &0#Iy))DAq 	z{^F(&C (
 &fmmo
FC	4  
g	.:3==;Q;QSVW 
/ &fQVn
EC	1  
g	.:3==;Q;QSVW 
/ &fmmBJJ6O
PC	#  
g	.:3==;Q;QSVW 
/	.! 
/	. 
/	. 
/	.s$   !D5)!E!E5D>E
Ec            	         d\  } }}t        | d|dddd      \  }}|| d  } G d d	t              }t        D ][  } | ||      
      }d|j                   d}	t	        t
        |	      5  t        |j                  j                  |       d d d        ]  ||j                         
      }d| d| d}	t	        t        |	      5  t        |j                  j                  |       d d d        t        |      D cg c]  }t        j                  |       }
} ||

      }d}	t	        t        |	      5  t        |j                  j                  |       d d d        t        |      D cg c]6  }t        j                  |j                  d   dft        j                        8 }
} ||

      }d}	t	        t        |	      5  t        |j                  j                  |       d d d        t        |      D cg c]6  }t        j                  |j                  d   dft        j                         8 }
} ||

      }d}	t	        t        |	      5  t        |j                  j                  |       d d d         ||d d d df   
      }d}	t	        t        |	      5  t        |j                  j                  |       d d d        t        j"                  |t        j                        }
 ||

      }d}	t	        t        |	      5  t        |j                  j                  |       d d d         ||dz  
      }d}	t	        t        |	      5  t        |j                  j                  |       d d d        y # 1 sw Y   QxY w# 1 sw Y   xY wc c}w # 1 sw Y   HxY wc c}w # 1 sw Y   xY wc c}w # 1 sw Y   NxY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   y xY w)NrM  r)  r  rQ  Tr   rR  c                       e Zd Zd Zy)gtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProbac                     | j                   S rt   rG  r   s     rd   predict_probazutest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProba.predict_probaq  r]  rf   N)rl   rm   rn   rm  rp   rf   rd    MultiLabelClassifierPredictProbark  p  r_  rf   rn  rG  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 ra  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\).)r   r<  zwWhen MultiLabelClassifierPredictProba.predict_proba returns a list, it should contain NumPy arrays with floating dtype.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\).)r<  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   rE  rR   rl   r(   r   r2   r   ra  r  ranger~   	ones_liker   r   r9  rc  
zeros_like)rS  rd  re  r  rx   rf  rn  r  rg  rA  rH  s              rd   =test_check_classifiers_multilabel_output_format_predict_probarr  c  s   &0#Iy))DAq 	z{^F(+H ( (.}V?TU&}'='=&> ?" " 	
 Jg.D&& /. ( +6==?
KC	K|I;a	9 
 
g	.@MM""	
 
/ 6;95EF5Er||F+5EOF
*?
KC	A 
 
g	.@MM""	
 
/ FK9EUEUv||A*"((;EU   +?
KC	>  
g	.@MM""	
 
/ HMYGWGW!v||A*"**=GW   +?
KC	) 
 
g	.@MM""	
 
/ +6!SbS&>
JC	" 
 
g	.@MM""	
 
/ mmF"((;O
*?
KC	6  
g	.@MM""	
 
/ +6C<
HC	O 
 
g	.@MM""	
 
/	.y /. 
/	. G 
/	. 
/	. 
/	. 
/	. 
/	. 
/	.sr   *!M>!N<N6!N,;N*!N/;;N<!O"!O!O!O'>N	NN'/N9OOO$'O0c            	      x   d\  } }}t        | d|dddd      \  }}|| d  } G d d	t              } ||j                         
      }d}t        t        |      5  t        |j                  j                  |       d d d         ||d d d df   
      }d}t        t        |      5  t        |j                  j                  |       d d d         ||
      }d}t        t        |      5  t        |j                  j                  |       d d d        y # 1 sw Y   xY w# 1 sw Y   [xY w# 1 sw Y   y xY w)NrM  r)  r  rQ  Tr   rR  c                       e Zd Zd Zy)otest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunctionc                     | j                   S rt   rG  r   s     rd   r  ztest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunction.decision_function  r]  rf   N)rl   rm   rn   r  rp   rf   rd   $MultiLabelClassifierDecisionFunctionru    r_  rf   rw  rG  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   rE  ra  r(   r  r0   r   rl   )	rS  rd  re  r  rx   rf  rw  rg  rA  s	            rd   Atest_check_classifiers_multilabel_output_format_decision_functionrx    s;   &0#Iy))DAq 	z{^F(/L (
 /v}}
OC	@  
g	.DMM""	
 
/ /va"f~
NC	* 
 
g	.DMM""	
 
/ /v
FC	'  
g	.DMM""	
 
/	./ 
/	. 
/	. 
/	.s$   !D)!D$.!D0D!$D-0D9c                  |   t         j                  d   } t        |       D cg c]  }|j                  d      rt	        | |      ! }}|D cg c]  }t        j                  |       }}t        j                         }|j                  |       t        j                         }|j                  |       yc c}w c c}w )z1Runs the tests in this file without using pytest.__main__test_N)r]   r^   dir
startswithgetattrunittestFunctionTestCase	TestSuiteaddTestsTextTestRunnerrun)main_moduler  test_functionsfnr	  suiterunners          rd   run_tests_without_pytestr    s    ++j)K $$D??7# 	T"$  
 ;II.B(++B/.JI E	NN:$$&F
JJu
 Js   $B4B9c                  |    d} t        t        |       5  t        dt                      d d d        y # 1 sw Y   y xY w)NzIClassifier estimator_name is not computing class_weight=balanced properlyr  r1  )r(   r  r-   r   r  s    rd   2test_check_class_weight_balanced_linear_classifierr  #  s.    
UC	c	*5:<	
 
+	*	*r  c                      t        j                  d      5 } t               }d d d         rJ D ])  }|j                  j                  j                  d      s)J  y # 1 sw Y   <xY w)NTr  r  )r  r  r   r   rl   r}  )r  
estimatorsr  s      rd   test_all_estimators_all_publicr  ,  s\     
	 	 	-#%
 
. :==))44S999 	 
.	-s   AA&rz  c                  6   t        t        t                    } t        |       }t	        | d|d      }t        |      dkD  sJ |D cg c]  }t        |d      s| }}t        |      dkD  sJ |D ]!  }|j                  d   }d|j                  vr!J  y c c}w )NTxfaillegacyr  r`   r   marksstrict)	nextr!   r   r"   rP   r-  r  r  r   )r  r  checkscmarked_checksparameter_set
first_marks          rd   +test_estimator_checks_generator_strict_noner  >  s    
#E*
+C237 (/	F  1$$$ &>1'!W*=QM>}!!!&"((+
z00000 '	 ?s   BBc                     t        t        t                    } t        |       }t	        | d|dd      }t        |      dkD  sJ g }|D cg c]  }t        |d      s| }}t        |      dkD  sJ |D ]J  }|j                  \  }}|j                  d   }	|	j                  d   s1|j                  t        |             L t        |j                               t        |      k(  sJ y c c}w )NTr  )r  r  r`   xfail_strictr   r  r  )r  r!   r   r"   rP   r-  r  valuesr  r   appendr)   r  r  )
r  r  r  strict_xfailed_checksr  r  r  r  checkr  s
             rd   2test_estimator_checks_generator_strict_xfail_testsr  U  s     #E*
+C237'/F  1$$$ !'>1'!W*=QM> 1$$$& ''5"((+
X&!((U);<	 ' $$&'3/D+EEEE ?s   
C)C)c                  R   t        t        t                    } t        |       }t	        | d|d      }t        |      dkD  sJ g }|D ]  \  }}	  ||        t        |j                               t        |      k  sJ y # t        $ r |j                  t        |             Y ^w xY w)NTskipr  r   )r  r!   r   r"   rP   r-  r&   r  r)   r  r  )r  r  r  skipped_checksr  r  s         rd   .test_estimator_checks_generator_skipping_testsr  u  s     #E*
+C237'D1AF  1$$$N"	5	6) # $$&'3~+>>>>	  	6!!+e"45	6s   B  #B&%B&c                     t               } t        |       }t        |      dkD  sJ t        j                  d      5 }t        | |d      }ddd       D cg c]  }|j                  t        k7  s| }}t        |D cg c]  }|j                  t        k(   c}      sJ t        |      t        |      k(  sJ D cg c]  }|d   dk(  s| }}t        |      t        |      k(  sJ y# 1 sw Y   xY wc c}w c c}w c c}w )	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  Nr  r  )
r   r"   r-  r  r  r8   r  r   r  r   )	r  r  r  logswxfail_warnsr  logxfaileds	            rd   "test_xfail_count_with_no_fast_failr    s    'C8=%&***		 	 	-#9
 
. &Gg)F1gKG{S{ ;;{STTT{s#9::::"?dsc(mw&>sdG?w<356666 
.	- HS @s)   C-C90C9?C>?DD-C6c                     dddddfd} t               }t        |      }t        |      dkD  sJ t        j                  d      5  t        ||d|        ddd       t        t        t        |d                  }d	   t        |      k(  sJ d
   dkD  sJ d   dk(  sJ d   |d	   z
  d
   z
  k(  sJ y# 1 sw Y   fxY w)z:Test that the callback is called with the right arguments.r   r  skippedr  r  c                 ,    |dv sJ |xx   dz  cc<   y )Nr  r   rp   )r  r  r  r  r  r  
call_counts         rd   callbackz/test_check_estimator_callback.<locals>.callback  s$     AAAA6arf   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       @rd   test_check_estimator_callbackr    s    a1EJ  'C8=%&***		 	 	-#9		
 
. 4 :3t LMNg#&<"====h!###h1$$$i :g..H1EE   
.	-s   	B>>Cc                      t         rt   )r&   r%   r$   r#   r8   )minimal_estimatorsr  s     rd   (test_minimal_class_implementation_checksr    s	     Nrf   c                       G d dt               } t        t        d      5  t        d | d             d d d        t        d | d             t        d | d	             y # 1 sw Y   0xY w)
Nc                   8    e Zd ZddZd Z ed       d        Zy)1test_check_fit_check_is_fitted.<locals>.Estimatorc                     || _         y rt   behavior)rv   r  s     rd   r   z:test_check_fit_check_is_fitted.<locals>.Estimator.__init__  s	    $DMrf   c                 b    | j                   dk(  r	d| _        | S | j                   dk(  rd| _        | S )N	attributeTr  )r  
is_fitted_
_is_fitted)rv   rw   rx   r   s       rd   ry   z5test_check_fit_check_is_fitted.<locals>.Estimator.fit  s6    }}+"& K (*"&Krf   c                     | j                   dv S )N>   r  always-truer  r"  s    rd   <lambda>z:test_check_fit_check_is_fitted.<locals>.Estimator.<lambda>  s    4==4M#Mrf   c                 :    | j                   dk(  ryt        | d      S )Nr  Tr  )r  r  r"  s    rd   __sklearn_is_fitted__zGtest_check_fit_check_is_fitted.<locals>.Estimator.__sklearn_is_fitted__  s    }}-4..rf   N)r  )rl   rm   rn   r   ry   rT   r  rp   rf   rd   r  r    s'    	%	 
M	N	/ 
O	/rf   r  z'passes check_is_fitted before being fitr  r  r  r  r  r  )r   r(   	ExceptionrB   )r  s    rd   test_check_fit_check_is_fittedr    sZ    /M /" 
	!J	K!+y-/PQ 
L k9h+GHk9k+JK	 
L	Ks   A$$A-c                  l    G d dt               } t        j                  d      5 }t        d |               d d d        D cg c]  }|j                   c}rJ  G d dt               }d}t        t        |	      5  t        d |              d d d        y # 1 sw Y   bxY wc c}w # 1 sw Y   y xY w)
Nc                       e Zd Zd Zy)-test_check_requires_y_none.<locals>.Estimatorc                 "    t        ||      \  }}y rt   )rX   ru   s      rd   ry   z1test_check_requires_y_none.<locals>.Estimator.fit  s    Q?DAqrf   Nr   rp   rf   rd   r  r    s    	#rf   r  Tr  r  c                       e Zd Zd Zy);test_check_requires_y_none.<locals>.EstimatorWithWrongErrorc                 |    	 t        ||      \  }}y # 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)rv   rw   rx   ves       rd   ry   z?test_check_requires_y_none.<locals>.EstimatorWithWrongError.fit  sR    	P A1 P 2wQ   !!NOOPs    	;6;Nr   rp   rf   rd   EstimatorWithWrongErrorr    s    
	Prf   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   messager(   r   )r  r  r   r  rA  s        rd   test_check_requires_y_noner    s    #M # 
	 	 	-k9;7 
. $**6a		6***P- P	E  

'	*k+B+DE 
+	*1 
.	- +( 
+	*s   BB%>B*B"*B3c                     t         t        t        fD ]k  } t        t	         |        d            }t
        |v sJ t        |v sJ  G d d|       }t        t	         |       d            }t
        |vsJ t        |vrkJ  y )NTr  c                        e Zd Z fdZ xZS )@test_non_deterministic_estimator_skip_tests.<locals>.MyEstimatorc                 2    t         |          }d|_        |S rz  )r   re  non_deterministicrh  s     rd   re  zQtest_non_deterministic_estimator_skip_tests.<locals>.MyEstimator.__sklearn_tags__  s    w/1)-&rf   rl   rm   rn   re  r   r   s   @rd   MyEstimatorr    s     rf   r  )r%   r$   r#   r  r+   rD   rE   )r  	all_testsr  s      rd   +test_non_deterministic_estimator_skip_testsr    s     )*:<MN	*9;tDE	4	AAA.);;;	) 	 *;=FG	4IEEE.i??? Orf   c            	      "    G d dt         t              }  |        }t        |j                  j                  |      J  G d d|       } |       }d}t        t        |      5  t        |j                  j                  |       ddd       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 ]S  }|g|j                  d<    |       }t        t        |      5  t        |j                  j                  |       ddd       U y# 1 sw Y   xY w# 1 sw Y   lxY w)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y)	Jtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraintz.Outlier detector without parameter validation.c                     || _         y rt   )contamination)rv   r  s     rd   r   zStest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.__init__)  s
    !.Drf   Nc                     | S rt   rp   )rv   rw   rx   r   s       rd   ry   zNtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.fit,  r.  rf   c                 F    t        j                  |j                  d         S r|   r}   ru   s      rd   r   zRtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.predict/  s    771771:&&rf   )g?rZ  rt   r2  rp   rf   rd    OutlierDetectorWithoutConstraintr  &  s    <	/		'rf   r  Nc                   $    e Zd Zd edh      giZy)Gtest_check_outlier_contamination.<locals>.OutlierDetectorWithConstraintr  autoN)rl   rm   rn   r    _parameter_constraintsrp   rf   rd   OutlierDetectorWithConstraintr  7  s    "1Jx4H3I!Jrf   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   rl   r(   r  r   r   r  r   )r  detectorr  rA  incorrect_intervalsintervals         rd    test_check_outlier_contaminationr  !  so   

'< 
' 01H&x'9'9'B'BHMUUUK(H K -.HTG	g	.#H$6$6$?$?J 
/
 	q#g.M!88I -.H 2 2 ; ;XF 	1a0r1W-q!G,q#f-	 NG'Q
%<<_M 12N'2'(:(:(C(CXN 32 (% 
/	.. 32s   #!E9!F9FF	c                  4    t        d      } t        d|        y)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    rd   test_decision_proba_tie_rankingr  W  s     :.I$_i@rf   c                  6   t               } t        t        | d            }t        t        | d            }t        |      t        |      kD  sJ d }|D ch c]
  } ||       }}|D ch c]
  } ||       }}|j	                  |      sJ y c c}w c c}w )NTr  Fc                 f    	 | j                   S # t        $ r | j                  j                   cY S w xY wrt   )rl   r  func)r  s    rd   get_check_namez4test_yield_all_checks_legacy.<locals>.get_check_namej  s0    	'>>! 	'::&&&	's    00)r#   r  r+   r-  issubset)r  legacy_checksnon_legacy_checksr  r  non_legacy_check_nameslegacy_check_namess          rd   test_yield_all_checks_legacyr  a  s    !#I*9TBCM.yGH}$5 6666' BSSARnU3ARS=JK]E./]K!**+=>>> TKs   B,Bc                       G d dt               }  |        }d}t        t        |      5  t        d|       ddd       y# 1 sw Y   yxY w)zICheck that the right error is raised when the estimator is not cloneable.c                       e Zd Zd Zy):test_check_estimator_cloneable_error.<locals>.NotCloneablec                     t        d      )Nz This estimator is not cloneable.NotImplementedErrorr"  s    rd   __sklearn_clone__zLtest_check_estimator_cloneable_error.<locals>.NotCloneable.__sklearn_clone__z  s    %&HIIrf   N)rl   rm   rn   r
  rp   rf   rd   NotCloneabler  y  s    	Jrf   r  zCloning of .* failed with errorr  N)r   r(   r  r9   )r  r  r  s      rd   $test_check_estimator_cloneable_errorr  v  s>    J} J I
+C	c	*!.)< 
+	*	*   A  A	c                       G d dt               }  |        }d}t        t        |      5  t        d|       ddd       y# 1 sw Y   yxY w)zMCheck that the right error is raised when the estimator does not have a repr.c                       e Zd Zd Zy)*test_estimator_repr_error.<locals>.NotReprc                     t        d      )Nz$This estimator does not have a repr.r  r"  s    rd   __repr__z3test_estimator_repr_error.<locals>.NotRepr.__repr__  s    %&LMMrf   N)rl   rm   rn   r  rp   rf   rd   NotReprr    s    	Nrf   r  zRepr of .* failed with errorr  N)r   r(   r  r:   )r  r  r  s      rd   test_estimator_repr_errorr    s>    N- N 	I
(C	c	*Y	2 
+	*	*r  c                  B    G d d      }  G d d      } G d d      }d}t        t        |      5  t        d |               d d d        t        t        |      5  t        d |              d d d        t        d |              y # 1 sw Y   FxY w# 1 sw Y   'xY w)	Nc                       e Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.BadEstimator1c                      y rt   rp   r"  s    rd   
_more_tagszCtest_check_estimator_tags_renamed.<locals>.BadEstimator1._more_tags      rf   N)rl   rm   rn   r  rp   rf   rd   BadEstimator1r        	rf   r  c                       e Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.BadEstimator2c                      y rt   rp   r"  s    rd   	_get_tagszBtest_check_estimator_tags_renamed.<locals>.BadEstimator2._get_tags  r  rf   N)rl   rm   rn   r   rp   rf   rd   BadEstimator2r    r  rf   r!  c                       e Zd Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.OkayEstimatorc                      y rt   rp   r"  s    rd   re  zItest_check_estimator_tags_renamed.<locals>.OkayEstimator.__sklearn_tags__  r  rf   c                      y rt   rp   r"  s    rd   r  zCtest_check_estimator_tags_renamed.<locals>.OkayEstimator._more_tags  r  rf   N)rl   rm   rn   re  r  rp   rf   rd   OkayEstimatorr#    s    		rf   r&  z.has defined either `_more_tags` or `_get_tags`r  )r(   r  r>   )r  r!  r&  r  s       rd   !test_check_estimator_tags_renamedr'    s{        ;C			%$_moF 
&			%$_moF 
& !-/B 
&	%	%	%s   B	B	BBc                       G d dt               } d}t        t        |      5  t        d |               ddd       y# 1 sw Y   yxY w)zeCheck that when the estimator has the wrong tags.classifier_tags.multi_class
    set, the test fails.c                       e Zd Zd Zy)Etest_check_classifier_not_supporting_multiclass.<locals>.BadEstimatorc                     | S rt   rp   ru   s      rd   ry   zItest_check_classifier_not_supporting_multiclass.<locals>.BadEstimator.fit  r.  rf   Nr   rp   rf   rd   BadEstimatorr*    s    	rf   r,  z=The estimator tag `tags.classifier_tags.multi_class` is Falser  N)r   r(   r  r/   r,  r  s     rd   /test_check_classifier_not_supporting_multiclassr.    s8    }  JC	c	*2><>R 
+	*	*s	   >Ac                      dD ]C  } 	 t        j                  |        t	               j                  |       }t        |dddd       E y # t        $ r t        d|  d      w xY w)N)r   polarszLibrary z is not installed)r  z_this check is expected to fail because pandas and polars are not compatible with the array api.)r,   check_array_api_mixed_inputscheck_array_api_same_namespace)r  r  )r  
__import__rO  r&   r   
set_outputr8   )libr  s     rd   test_estimator_with_set_outputr6    s~     $	>  % #$//#/>	>>>$	
 $  	>XcU*;<==	>s   A

A#c                  D    t        t                     } t        |       sJ y)z0Check that checks_generator returns a generator.N)rP   r   r   )all_instance_gen_checkss    rd   test_estimator_checks_generatorr9    s     89K9MN.///rf   c                  ~    t        t        d      5  t        t               dd        ddd       y# 1 sw Y   yxY w)zMCheck that check_estimator fails correctly with on_fail='raise' and callback.z9callback cannot be provided together with on_fail='raise'r  raisec                       y rt   rp   rp   rf   rd   r  zDtest_check_estimator_callback_with_fast_fail_error.<locals>.<lambda>  s    PTrf   )r  r  N)r(   r   r8   r   rp   rf   rd   2test_check_estimator_callback_with_fast_fail_errorr=    s2    	U
 	*,gU
 
 
s   3<c                       G d dt         t              } d}t        t        t	        j
                  |            5  t        d |               ddd       y# 1 sw Y   yxY w)zFTest that the check raises an error when the mixin order is incorrect.c                       e Zd ZddZy),test_check_mixin_order.<locals>.BadEstimatorNc                     | S rt   rp   ru   s      rd   ry   z0test_check_mixin_order.<locals>.BadEstimator.fit  r.  rf   rt   r   rp   rf   rd   r,  r@    s    	rf   r,  z8TransformerMixin comes before/left side of BaseEstimatorr  N)r   r   r(   r  reescaperF   r-  s     rd   test_check_mixin_orderrD    sC    }&6  EC	biin	5.,.9 
6	5	5s   AAc                       G d dt               } t        t        d      5  t        d |               d d d        y # 1 sw Y   y xY w)Nc                        e Zd Z fdZ xZS )Htest_check_positive_only_tag_during_fit.<locals>.RequiresPositiveXBadTagc                 F    t         |          }d|j                  _        |S rd  )r   re  rr  rs  rh  s     rd   re  zYtest_check_positive_only_tag_during_fit.<locals>.RequiresPositiveXBadTag.__sklearn_tags__  s!    7+-D,1DOO)Krf   r  r   s   @rd   RequiresPositiveXBadTagrG    s    	 	rf   rI  z5This happens when passing negative input values as X.r  )rl  r(   r  rK   )rI  s    rd   'test_check_positive_only_tag_during_fitrJ    sB    "<  
U
 	+%'>'@	

 
 
s	   <A)r  rB  r]   r  r  inspectr   numbersr   r   r  numpyr~   scipy.sparsert  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   re   ri   r   rk   rr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r$  r4  rA  rJ  rS  r\  rl  rv  r}  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r4  r9  r<  r?  rC  rE  rh  rr  rx  r  r  r  rl   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r'  r.  r6  r9  r=  rD  rJ  rp   rf   rd   <module>ra     s  
  	 
    "    . W W + & 
  , 1 0 " @ @ @ * * * * * * * * * * *V @ 5 3 J # ##- # M  ] "= 	] 	 "= &( #* #(	#&7 	##] #(#4 , $- $ m *"#$5 "#J   F((- ("4] 4,} 5 "!1  
!1 
"4 	= 	'] '
0	L,R (9 (9I4"L	F
V<
E6 , (!3 (	 ,
!3H-,P^6 ,, ,,D	N.
h (
R (
R

L 
O] 
(XVy
x2
j
 (: (: z 1.F@ (? (?( (7 (70"N#L2FB@&3OlA?*
=
3C8S  (
 (
80V	:
rf   