
    sgl                     J   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`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZj d dlkmlZlmmZm d dlnmoZo d dlpmqZq d dlrmsZsmtZtmuZumvZv  G d dew      Zx G d dee      Zy G d de      Zz 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/ey      Z G d0 d1ey      Z G d2 d3ey      Z G d4 d5e      Z G d6 d7ey      Z G d8 d9e      Z G d: d;e      Z G d< d=e      Z G d> d?ey      Z G d@ dAe      Z G dB dCee      Z G dD dEe      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      ZdT ZdU ZdV ZdW ZdX ZdY ZdZ Zd[ Zd\ Zd] Zd^ Zd_ Zd` Zda Zdb Zdc Zdd Zde Zdf Zdg Zdh Zdi Zdj Zdk Zdl Zdm Z G dn doee      Zdp Zdq Zdr Zds Zdt Zdu Zedvk(  r e        dw Zdx Zdy Zdz Zd{ Zd| Zd} Zd~ Zd Zd Zd Zd Zd Zd Zd 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_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                       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__     \/var/www/html/venv/lib/python3.12/site-packages/sklearn/utils/tests/test_estimator_checks.pyrZ   rZ   k   s    r`   rZ   c                       e Zd Zd Zd Zy)BaseBadClassifierc                     | S Nr_   selfXys      ra   fitzBaseBadClassifier.fitt       r`   c                 F    t        j                  |j                  d         S Nr   nponesshaperg   rh   s     ra   predictzBaseBadClassifier.predictw   s    wwqwwqz""r`   Nr[   r\   r]   rj   rs   r_   r`   ra   rc   rc   s   s    #r`   rc   c                   "    e Zd ZddZddZd Zy)ChangesDictc                     || _         y re   )key)rg   rx   s     ra   __init__zChangesDict.__init__|   s	    r`   Nc                 &    t        | ||      \  }}| S re   rX   rf   s      ra   rj   zChangesDict.fit       T1a(1r`   c                 j    t        |      }d| _        t        j                  |j                  d         S )Ni  r   )rU   rx   ro   rp   rq   rr   s     ra   rs   zChangesDict.predict   s)    Nwwqwwqz""r`   r   re   r[   r\   r]   ry   rj   rs   r_   r`   ra   rv   rv   {   s    #r`   rv   c                       e Zd ZddZddZy)SetsWrongAttributec                     || _         y re   )acceptable_key)rg   r   s     ra   ry   zSetsWrongAttribute.__init__   s
    ,r`   Nc                 4    d| _         t        | ||      \  }}| S rm   wrong_attributerX   rf   s      ra   rj   zSetsWrongAttribute.fit   !     T1a(1r`   r~   re   r[   r\   r]   ry   rj   r_   r`   ra   r   r      s    -r`   r   c                       e Zd ZddZddZy)ChangesWrongAttributec                     || _         y re   )r   )rg   r   s     ra   ry   zChangesWrongAttribute.__init__   
    .r`   Nc                 4    d| _         t        | ||      \  }}| S N   r   rf   s      ra   rj   zChangesWrongAttribute.fit   r   r`   r~   re   r   r_   r`   ra   r   r      s    /r`   r   c                       e Zd ZddZy)ChangesUnderscoreAttributeNc                 4    d| _         t        | ||      \  }}| S r   )_good_attributerX   rf   s      ra   rj   zChangesUnderscoreAttribute.fit   r   r`   re   r[   r\   r]   rj   r_   r`   ra   r   r      s    r`   r   c                   .     e Zd ZddZ fdZddZ xZS )RaisesErrorInSetParamsc                     || _         y re   prg   r   s     ra   ry   zRaisesErrorInSetParams.__init__   	    r`   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 0r_   )pop
ValueErrorr   super
set_paramsrg   kwargsr   	__class__s      ra   r   z!RaisesErrorInSetParams.set_params   sD    &=

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

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

3ADFy

3"w!+F++r`   c                 &    t        | ||      \  }}| S re   r{   rf   s      ra   rj   zModifiesAnotherValue.fit   r|   r`   )r   method1re   r   r   s   @ra   r   r      s    ,r`   r   c                       e Zd Zd Zy)NoCheckinPredictc                 &    t        | ||      \  }}| S re   r{   rf   s      ra   rj   zNoCheckinPredict.fit   r|   r`   Nr   r_   r`   ra   r   r      s    r`   r   c                        e Zd ZddZd Zd Zy)NoSparseClassifierNc                     || _         y re   raise_for_typerg   r   s     ra   ry   zNoSparseClassifier.__init__   
    ,r`   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)rX   r   
isinstancespsparrayspmatrixr   rg   rh   ri   correct_types       ra   rj   zNoSparseClassifier.fit   sj    T1au~F1.0%a4L  O3%a5L011r`   c                 \    t        |      }t        j                  |j                  d         S rm   rU   ro   rp   rq   rr   s     ra   rs   zNoSparseClassifier.predict  "    Nwwqwwqz""r`   re   r   r_   r`   ra   r   r      s    -#r`   r   c                       e Zd Zd Zd Zy)CorrectNotFittedErrorClassifierc                 t    t        | ||      \  }}t        j                  |j                  d         | _        | S r   )rX   ro   rp   rq   coef_rf   s      ra   rj   z#CorrectNotFittedErrorClassifier.fit	  s1    T1a(1WWQWWQZ(
r`   c                 r    t        |        t        |      }t        j                  |j                  d         S rm   )rV   rU   ro   rp   rq   rr   s     ra   rs   z'CorrectNotFittedErrorClassifier.predict  s*    Nwwqwwqz""r`   Nrt   r_   r`   ra   r   r     s    
#r`   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)rX   pandasr   r   r   )rg   rh   ri   sample_weightr   s        ra   rj   z"NoSampleWeightPandasSeriesType.fit  sD    !Qn4SW
1 	"mV,P  r`   c                 \    t        |      }t        j                  |j                  d         S rm   r   rr   s     ra   rs   z&NoSampleWeightPandasSeriesType.predict#  r   r`   re   rt   r_   r`   ra   r   r     s    #r`   r   c                       e Zd ZddZd Zy)BadBalancedWeightsClassifierNc                     || _         y re   )class_weight)rg   r   s     ra   ry   z%BadBalancedWeightsClassifier.__init__)  s
    (r`   c                     ddl m} ddlm}  |       j	                  |      }|j
                  } || j                  ||      }| j                  dk(  r|dz  }|| _        | S )Nr   )LabelEncoder)compute_class_weight)classesri   balanced      ?)sklearn.preprocessingr   sklearn.utilsr   rj   classes_r   r   )rg   rh   ri   r   r   label_encoderr   r   s           ra   rj   z BadBalancedWeightsClassifier.fit,  sb    66$**1-((+D,=,=wRST 
*CL "
r`   re   r   r_   r`   ra   r   r   (  s    )r`   r   c                       e Zd ZddZd Zy)BadTransformerWithoutMixinNc                     t        | |      }| S re   r{   rf   s      ra   rj   zBadTransformerWithoutMixin.fit?  s    $"r`   c                 8    t        |        t        | |d      }|S )NFreset)rV   rX   rr   s     ra   	transformz$BadTransformerWithoutMixin.transformC  s    $/r`   re   )r[   r\   r]   rj   r  r_   r`   ra   r   r   >  s    r`   r   c                       e Zd Zd Zd Zy)NotInvariantPredictc                 .    t        | ||ddd      \  }}| S Nr   Tr   r{   rf   s      ra   rj   zNotInvariantPredict.fitJ  s%    !Qn4SW
1 r`   c                     t        |      }|j                  d   dkD  r"t        j                  |j                  d         S t        j                  |j                  d         S )Nr   r   )rU   rq   ro   rp   zerosrr   s     ra   rs   zNotInvariantPredict.predictQ  sH    N771:>771771:&&xx
##r`   Nrt   r_   r`   ra   r  r  I  s    $r`   r  c                       e Zd Zd Zd Zy)NotInvariantSampleOrderc                 <    t        | ||ddd      \  }}|| _        | S r  )rX   _Xrf   s      ra   rj   zNotInvariantSampleOrder.fitZ  s,    !Qn4SW
1 r`   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)rU   ro   array_equivsortr  anyr	  rq   rr   s     ra   rs   zNotInvariantSampleOrder.predictb  sm    N NN27711-rwwtwwQ/GHdgg""$88AGGAJ''Awr`   Nrt   r_   r`   ra   r  r  Y  s    	r`   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 re   )raise_when_single_class)rg   r  s     ra   ry   z&OneClassSampleErrorClassifier.__init__r  s
    '>$r`   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   )rW   has_single_class_ro   uniquer   rq   r  r   r   ndarraylencount_nonzerobincount)rg   rh   ri   r   
n_classes_s        ra   rj   z!OneClassSampleErrorClassifier.fitu  s    qTT
1 "'99Qt<q]]((+
>d::%)D"122 $-4]9Ka9O--bkk!].KL
A~)-& !455r`   c                     t        |        t        |      }| j                  r"t        j                  |j
                  d         S t        j                  |j
                  d         S rm   )rV   rU   r  ro   r	  rq   rp   rr   s     ra   rs   z%OneClassSampleErrorClassifier.predict  sJ    N!!88AGGAJ''wwqwwqz""r`   )Fre   r[   r\   r]   r^   ry   rj   rs   r_   r`   ra   r  r  n  s    #?,#r`   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 re   r   r   s     ra   ry   z*LargeSparseNotSupportedClassifier.__init__  r   r`   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   r'  int64z(Estimator doesn't support 64-bit indices)r   r   )rX   r   r   r   r   r   formatrowdtypecolr   indicesindptrr   s       ra   rj   z%LargeSparseNotSupportedClassifier.fit  s    / $
1 .0%a4L  O3%a5Lxx5 55;;')QUU[[G-C$%OPP  ^+IIOOHHNN'  > >> 
 r`   re   )r[   r\   r]   r^   ry   rj   r_   r`   ra   r$  r$    s    /-r`   r$  c                   *    e Zd ZddZddZddZd Zy)SparseTransformerNc                     || _         y re   sparse_container)rg   r4  s     ra   ry   zSparseTransformer.__init__  s
     0r`   c                     t        | |       | S re   r{   rf   s      ra   rj   zSparseTransformer.fit  s    dAr`   c                 D    | j                  ||      j                  |      S re   )rj   r  rf   s      ra   fit_transformzSparseTransformer.fit_transform  s    xx1~''**r`   c                 X    t        |        t        | |dd      }| j                  |      S )NTF)r   r  )rV   rX   r4  rr   s     ra   r  zSparseTransformer.transform  s+    $UC$$Q''r`   re   )r[   r\   r]   ry   rj   r7  r  r_   r`   ra   r1  r1    s    1+(r`   r1  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   r<  r   ilocvalue_rU   ImportError)rg   rh   ri   r<  s       ra   rj   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 rm   )rU   ro   arrayr>  rq   rr   s     ra   rs   z&EstimatorInconsistentForPandas.predict  s-    Nxx
233r`   Nrt   r_   r`   ra   r:  r:    s     4r`   r:  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   rj   r  r   r   )rg   rh   ri   	coef_initintercept_initr   r   s         ra   rj   zUntaggedBinaryClassifier.fit  s9    Aq)^]Ct}}!;<<r`   c                 t    t         |   ||||       t        | j                        dkD  rt	        d      | S )N)rh   ri   r   r   r  rE  )r   partial_fitr  r   r   )rg   rh   ri   r   r   r   s        ra   rI  z$UntaggedBinaryClassifier.partial_fit  s;    a1g]St}}!;<<r`   )NNNNN)r[   r\   r]   rj   rI  r   r   s   @ra   rC  rC    s     r`   rC  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 )Nri   T)
input_nameraise_unknownbinaryzCOnly binary classification is supported. The type of the target is .)rT   r   r   rj   )rg   rh   ri   y_typer   s       ra   rj   zTaggedBinaryClassifier.fit  sJ    cFXXQ   w{1a  r`   c                 F    t         |          }d|j                  _        |S NF)r   __sklearn_tags__classifier_tagsmulti_classrg   tagsr   s     ra   rU  z'TaggedBinaryClassifier.__sklearn_tags__  s#    w')+0(r`   r[   r\   r]   rj   rU  r   r   s   @ra   rL  rL    s    ! r`   rL  c                   (     e Zd Z fdZ fdZ xZS )RequiresPositiveXRegressorc                     t        | ||d      \  }}|dk  j                         rt        d      t        |   ||      S )NTr   r   z$Negative values in data passed to X.rX   r  r   r   rj   rg   rh   ri   r   s      ra   rj   zRequiresPositiveXRegressor.fit  sA    T1ad;1E;;=CDDw{1a  r`   c                 F    t         |          }d|j                  _        |S NTr   rU  
input_tagspositive_onlyrX  s     ra   rU  z+RequiresPositiveXRegressor.__sklearn_tags__  s!    w')(,%r`   rZ  r   s   @ra   r\  r\        ! r`   r\  c                   (     e Zd Z fdZ fdZ xZS )RequiresPositiveYRegressorc                     t        | ||d      \  }}|dk  j                         rt        d      t        |   ||      S )NTr^  r    negative y values not supported!r_  r`  s      ra   rj   zRequiresPositiveYRegressor.fit  sA    T1ad;1F<<>?@@w{1a  r`   c                 F    t         |          }d|j                  _        |S rb  )r   rU  target_tagsre  rX  s     ra   rU  z+RequiresPositiveYRegressor.__sklearn_tags__  s#    w'))-&r`   rZ  r   s   @ra   rh  rh  
  rf  r`   rh  c                   (     e Zd Z fdZ fdZ xZS )PoorScoreLogisticRegressionc                 (    t         |   |      dz   S r   )r   decision_function)rg   rh   r   s     ra   rp  z-PoorScoreLogisticRegression.decision_function  s    w(+a//r`   c                 F    t         |          }d|j                  _        |S rb  )r   rU  rV  
poor_scorerX  s     ra   rU  z,PoorScoreLogisticRegression.__sklearn_tags__  s#    w')*.'r`   )r[   r\   r]   rp  rU  r   r   s   @ra   rn  rn    s    0 r`   rn  c                       e Zd Zd Zd Zy)PartialFitChecksNamec                      t        | ||       | S re   r{   rf   s      ra   rj   zPartialFitChecksName.fit"  s    dAq!r`   c                 L    t        | d       }t        | |||       d| _        | S )N_fittedr  T)hasattrrX   rw  )rg   rh   ri   r  s       ra   rI  z PartialFitChecksName.partial_fit&  s+    D),,dAq.r`   N)r[   r\   r]   rj   rI  r_   r`   ra   rt  rt  !  s    r`   rt  c                       e Zd ZdZd Zd Zy)BrokenArrayAPIz=Make different predictions when using Numpy and the Array APIc                     | S re   r_   rf   s      ra   rj   zBrokenArrayAPI.fit0  rk   r`   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asarrayro   rA  )rg   rh   enabledxp_s        ra   rs   zBrokenArrayAPI.predict3  sD    ,34((+A::i((88I&&r`   N)r[   r\   r]   r^   rj   rs   r_   r`   ra   rz  rz  -  s    G'r`   rz  c                  6   	 t        j                  d       	 t        j                  d       t	        t
        d      5  t        dt               dd	       d d d        y # t        $ r t        d      w xY w# t        $ r t        d      w xY w# 1 sw Y   y xY w)
Narray_api_compatz-array_api_compat is required to run this testarray_api_strictz-array-api-strict is required to run this testNot equal to tolerancematchrz  T)array_namespacecheck_values)	importlibimport_moduleModuleNotFoundErrorr&   r(   AssertionErrorr,   rz  r_   r`   ra   test_check_array_api_inputr  <  s    H 23H 23 
&>	? 
.		

 
  HFGGH  HFGGH
 
s!   A A7 BA47BB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*   ro   rp   r(   	TypeErrorsummay_share_memory)	not_arraymsgs     ra    test_not_an_array_array_functionr  O  s\    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 re   r_   rf   s      ra   rj   zftest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethod.fit]  s    Kr`   N)r[   r\   r]   r   rj   r_   r`   ra   $TestEstimatorWithDeprecatedFitMethodr  \  s    	S	T	 
U	r`   r  test)r   rB   )r  s    ra   4test_check_fit_score_takes_y_works_on_deprecated_fitr  X  s    } 
 F$H$JKr`   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    ra   'test_check_estimator_with_class_removedr  d  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)rI   r   r(   r  r   r  s    ra   test_mutable_default_paramsr  k  sR    	& 
 ++- 
c	* R.y:N:PQR R R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  rN   r   warningscatch_warningsr   UserWarningcategoryr   )r  recordsrecs      ra   test_check_set_paramsr  y  s     KC	c	* G!C!EFG 
	 	 	- ;!7!9:;7;C3<<;;;;	c	* 9!5!789 9G G; ;;9 9s)   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    ra   test_check_estimators_nan_infr    s9    
OC	c	* I !35E5GHI I I   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   rv   r  s    ra   test_check_dict_unchangedr    s4     6C	c	* 4V[]34 4 4r  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   rM   r   r?  )r   r  s     ra   'test_check_sample_weights_pandas_seriesr    sZ    !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    ra   &test_check_estimators_overwrite_paramsr    sO    	@  
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    ra   $test_check_dont_overwrite_parametersr    s?    	,  
c	* F'0B0DEF F F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)Nrs   zY{method} of {name} is not invariant when applied to a datasetwith different sample order.methodnamer  r  )r  r[   r*  r(   r  rC   r  r  r  s      ra   *test_check_methods_sample_order_invariancer    s\    "++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)Nrs   z={method} of {name} is not invariant when applied to a subset.r  r  r  )r  r[   r*  r(   r  rD   r  s      ra   $test_check_methods_subset_invariancer    sa    ''DFJ
R
RD S C 
c	* V'(=?R?TUV V V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.*r$  )r   r[   r(   r  r<   rR   r;   r$  r  r  s     ra    test_check_estimator_sparse_datar    s   &&D
G$
NC	c	* Q%d,>,OPQ N#. 	S(/A./QR	S
	D  
c	* 
%/-o>	

 N#. 	(31.A	 	 %Q Q	S 	S
 
	 	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  r[   r(   r  r3   r  s     ra   /test_check_classifiers_one_label_sample_weightsr    sS    (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     ra   	<genexpr>z5test_check_estimator_not_fail_fast.<locals>.<genexpr>  sC        	4 		
		

		
s   :<c              3   ,   K   | ]  }|d    dk(    yw)r  failedNr_   r  s     ra   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>       DdtH~)D   c              3   ,   K   | ]  }|d    dk(    yw)r  passedNr_   r  s     ra   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>  r  r  )r8   r   r   listr  allr  )check_resultss    ra   "test_check_estimator_not_fail_fastr    s     $MOTBMmT***}!!!  "    DmDDDDDmDDDDr`   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  rE  r3  g{Gz?)Crj  )r(   AttributeErrorr8   r   r   rC  rQ   r1  r   r   rL  r\  rh  rn  )r  csr_containers     ra   test_check_estimatorr  "  s   
 *C	c	* )() )C	
#	& 40234 ( K)=IJK
 &()&./')* *,-.01 -C	
#	& 62456 /127) )
4 4$6 6s#   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  )ro   rA  r(   r  rH   )decisions    ra   test_check_outlier_corruptionr  F  sW    xx,-H		 1 Ax01 xx,-HQ8,	1 1s   A""A+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   r_   r`   ra   )test_check_estimator_transformer_no_mixinr  P  s0     
E	F 62456 6 6s   .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   rP   joblibhashr8   r"   rj   datatarget)iris	Estimatorestold_hashs       ra   test_check_estimator_clonesr  W  s    ;D 	 ,	 &89 	+CS!{{3'H,G,L		 6;;s++++ &89 	+CS!GGDIIt{{+{{3'H,G,L	 6;;s++++5,	 		 	s   >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  r@   r   r   r  s    ra   test_check_estimators_unfittedr  y  sK     AC	c	* E!+/A/CDE
 k+J+LME E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 re   )you_should_not_set_this_rg   s    ra   ry   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSet.__init__  s
    ,0D)r`   Nr[   r\   r]   ry   r_   r`   ra    NonConformantEstimatorPrivateSetr    s    	1r`   r  c                       e Zd ZddZy)Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSetNc                      y re   r_   )rg   you_should_set_this_s     ra   ry   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSet.__init__  s    r`   re   r  r_   r`   ra    NonConformantEstimatorNoParamSetr	    s    	r`   r  c                       e Zd ZddiZy)Otest_check_no_attributes_set_in_init.<locals>.ConformantEstimatorClassAttributefooTN)r[   r\   r]   9_ConformantEstimatorClassAttribute__metadata_request__fitr_   r`   ra   !ConformantEstimatorClassAttributer    s    #($-r`   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  rF   r  r   set_fit_request)r  r  r  r  s       ra   $test_check_no_attributes_set_in_initr    s    1= 1= 0M 0
	= 
 
c	* 
'>@	

	  
c	* 
'>@	

 $;= 
	5 
'-/??D?I	

 
+
 

 

 
s$   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    ra   test_check_estimator_pairwiser    s2    
 ]
#CC ]
3CC0KC0PQr`   c                  x    t        t        d      5  t        dt                      d d d        y # 1 sw Y   y xY wNr  r  r  )r(   r  r.   r:  r_   r`   ra   'test_check_classifier_data_not_an_arrayr    s3    	&>	? 
*<>	

 
 
   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  rK   r:  r_   r`   ra   &test_check_regressor_data_not_an_arrayr     s3    	&>	? 
)<>	

 
 
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  r  z;Docstring that does not document the estimator's attributeszNEstimator LogisticRegression does not document its feature_names_in_ attribute)	r(   r   r4   rc   rt  r   r   r[   r^   )err_msglrs     ra   -test_check_dataframe_column_names_consistencyr$    s    ;G	
'	* X01ACTCVWX,-=?S?UV		B,R\\-B-BBGNBJX  

'	* L01F1FKL LX XL Ls   B3	!B?3B<?Cc                   *     e Zd Zd Zd Z fdZ xZS )_BaseMultiLabelClassifierMockc                     || _         y re   response_output)rg   r)  s     ra   ry   z&_BaseMultiLabelClassifierMock.__init__  r   r`   c                     | S re   r_   rf   s      ra   rj   z!_BaseMultiLabelClassifierMock.fit  rk   r`   c                 F    t         |          }d|j                  _        |S rb  )r   rU  rV  multi_labelrX  s     ra   rU  z._BaseMultiLabelClassifierMock.__sklearn_tags__  s#    w')+/(r`   )r[   r\   r]   ry   rj   rU  r   r   s   @ra   r&  r&    s    / r`   r&  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 re   r(  rr   s     ra   rs   zdtest_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredict.predict      '''r`   N)r[   r\   r]   rs   r_   r`   ra   MultiLabelClassifierPredictr<        	(r`   r?  r(  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   r&  tolistr(   r  r1   r   r[   astypero   float64)	r4  	test_size	n_outputsr  ri   y_testr?  clfr"  s	            ra   7test_check_classifiers_multilabel_output_format_predictrI    sb   &0#Iy))DAq 	z{^F(&C (
 &fmmo
FC	4  
g	. X:3==;Q;QSVWX &fQVn
EC	1  
g	. X:3==;Q;QSVWX &fmmBJJ6O
PC	#  
g	. X:3==;Q;QSVWX X!X XX XX X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)Nr.  r  r~  r2  Tr   r3  c                       e Zd Zd Zy)gtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProbac                     | j                   S re   r(  rr   s     ra   predict_probazutest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProba.predict_proba$  r>  r`   N)r[   r\   r]   rN  r_   r`   ra    MultiLabelClassifierPredictProbarL  #  r@  r`   rO  r(  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 rQ  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\).)rq   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 1rA  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   r&  rQ   r[   r(   r   r2   r   rB  r  rangero   	ones_likerp   rq   r)  rD  
zeros_like)r4  rE  rF  r  ri   rG  rO  r  rH  r"  r)  s              ra   =test_check_classifiers_multilabel_output_format_predict_probarS    s   &0#Iy))DAq 	z{^F(+H ( ( .}V?TU&}'='=&> ?" " 	
 Jg. 	D&&	 	 +6==?
KC	K|I;a	9 
 
g	. 
@MM""	

 6;95EFr||F+FOF
*?
KC	A 
 
g	. 
@MM""	

 FK9EU@Av||A*"((;O  +?
KC	>  
g	. 
@MM""	

 HMYGWBCv||A*"**=O  +?
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)Nr.  r  r~  r2  Tr   r3  c                       e Zd Zd Zy)otest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunctionc                     | j                   S re   r(  rr   s     ra   rp  ztest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunction.decision_function  r>  r`   N)r[   r\   r]   rp  r_   r`   ra   $MultiLabelClassifierDecisionFunctionrV    r@  r`   rX  r(  zwMultiLabelClassifierDecisionFunction.decision_function is expected to output a NumPy array. Got <class 'list'> instead.r  rA  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   r&  rB  r(   r  r0   r   r[   )	r4  rE  rF  r  ri   rG  rX  rH  r"  s	            ra   Atest_check_classifiers_multilabel_output_format_decision_functionrY    sR   &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)sysmodulesdir
startswithgetattrunittestFunctionTestCase	TestSuiteaddTestsTextTestRunnerrun)main_moduler  test_functionsfn
test_casessuiterunners          ra   run_tests_without_pytestrn    s    ++j)K $??7# 	T"N 
 ;IIB(++B/IJ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  r  )r(   r  r-   r   r  s    ra   2test_check_class_weight_balanced_linear_classifierrp    s7    
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   r[   r`  )r  
estimatorsr  s      ra   test_all_estimators_all_publicrs    sh     
	 	 	- &#%
& : :==))44S999:	& &s   AA&r[  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skip)legacyr  markr   )nextr!   r   r"   rO   r  r&   appendr)   r  r  )r  r  checksskipped_checksr  checks         ra   .test_estimator_checks_generator_skipping_testsr}    s    
#E*
+C237'D1AF  1$$$N" 6	5	6)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  xfail)
r   r"   r  r  r  r8   r  r   r  r   )	r  r  r  logswxfail_warnsr  logxfaileds	            ra   "test_xfail_count_with_no_fast_failr    s    'C8=%&***		 	 	- 
#9

 &G)F1GKG{S ;;STTT{s#9::::"?sc(mw&>s?G?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   r_   )r  r  r  r  r  r  
call_counts         ra   callbackz/test_check_estimator_callback.<locals>.callback   s$     AAAA6ar`   Tr  N)r  r  r  rv  r  r  r  r  )r   r"   r  r  r  r8   r  rO   )r  r  r  r  r  all_checks_countr  s         @ra   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         re   )r&   r%   r$   r#   r8   )minimal_estimatorsr  s     ra   (test_minimal_class_implementation_checksr  C  s	     Nr`   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 re   behavior)rg   r  s     ra   ry   z:test_check_fit_check_is_fitted.<locals>.Estimator.__init__O  s	    $DMr`   c                 b    | j                   dk(  r	d| _        | S | j                   dk(  rd| _        | S )N	attributeTr  )r  
is_fitted_
_is_fitted)rg   rh   ri   r   s       ra   rj   z5test_check_fit_check_is_fitted.<locals>.Estimator.fitR  s6    }}+"& K (*"&Kr`   c                     | j                   dv S )N>   r  always-truer  r  s    ra   <lambda>z:test_check_fit_check_is_fitted.<locals>.Estimator.<lambda>Y  s    4==4M#M r`   c                 :    | j                   dk(  ryt        | d      S )Nr  Tr  )r  rx  r  s    ra   __sklearn_is_fitted__zGtest_check_fit_check_is_fitted.<locals>.Estimator.__sklearn_is_fitted__Y  s    }}-4..r`   N)r  )r[   r\   r]   ry   rj   rS   r  r_   r`   ra   r  r  N  s'    	%	 
M	N	/ 
O	/r`   r  z'passes check_is_fitted before being fitr  r  r  r  r  r  )r   r(   	ExceptionrA   )r  s    ra   test_check_fit_check_is_fittedr  M  sc    /M /" 
	!J	K R!+y-/PQR k9h+GHk9k+JK	R Rs   A$$A-c                       G d dt               } t        j                  d      5 }t        d |               d d d        D cg c]  }|j                   c}rJ y # 1 sw Y   &xY wc c}w )Nc                       e Zd Zd Zy)-test_check_requires_y_none.<locals>.Estimatorc                 "    t        ||      \  }}y re   )rW   rf   s      ra   rj   z1test_check_requires_y_none.<locals>.Estimator.fith  s    Q?DAqr`   Nr   r_   r`   ra   r  r  g  s    	#r`   r  Tr  r  )r   r  r  rL   message)r  r  r   s      ra   test_check_requires_y_noner  f  sb    #M # 
	 	 	- 8k9;78 $**a		****	8 8 +s   AA)A&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 rb  )r   rU  non_deterministicrX  s     ra   rU  zQtest_non_deterministic_estimator_skip_tests.<locals>.MyEstimator.__sklearn_tags__{  s    w/1)-&r`   r[   r\   r]   rU  r   r   s   @ra   MyEstimatorr  z  s     r`   r  )r%   r$   r#   r  r+   rC   rD   )r  	all_testsr  s      ra   +test_non_deterministic_estimator_skip_testsr  r  s     )*:<MN @	*9;tDE	4	AAA.);;;	) 	 *;=FG	4IEEE.i???@r`   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 re   )contamination)rg   r  s     ra   ry   zStest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.__init__  s
    !.Dr`   Nc                     | S re   r_   )rg   rh   ri   r   s       ra   rj   zNtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.fit      Kr`   c                 F    t        j                  |j                  d         S rm   rn   rf   s      ra   rs   zRtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.predict  s    771771:&&r`   )g?rJ  re   r"  r_   r`   ra    OutlierDetectorWithoutConstraintr    s    <	/		'r`   r  Nc                   $    e Zd Zd edh      giZy)Gtest_check_outlier_contamination.<locals>.OutlierDetectorWithConstraintr  autoN)r[   r\   r]   r    _parameter_constraintsr_   r`   ra   OutlierDetectorWithConstraintr    s    "1Jx4H3I!Jr`   r  zDcontamination constraints should contain a Real Interval constraint.r  r   g      ?right)closedr  r   rA  r  leftz<contamination constraint should be an interval in \(0, 0.5\])r
   r   rG   r   r[   r(   r  r   r   r  r   )r  detectorr  r"  incorrect_intervalsintervals         ra    test_check_outlier_contaminationr    s   

'< 
' 01H&x'9'9'B'BHMUUUK(H K -.HTG	g	. K#H$6$6$?$?JK
 	q#g.M!88I -.H 2 2 ; ;XF 	1a0r1W-q!G,q#f-	 NG' OQ
%<<_M 12N'2 	O'(:(:(C(CXN	O 	OO%K K.	O 	Os   #!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    ra   test_decision_proba_tie_rankingr    s     :.I$_i@r`   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re   )r[   r  func)r|  s    ra   get_check_namez4test_yield_all_checks_legacy.<locals>.get_check_name  s0    	'>>! 	'::&&&	's    00)r#   r  r+   r  issubset)r  legacy_checksnon_legacy_checksr  r|  non_legacy_check_nameslegacy_check_namess          ra   test_yield_all_checks_legacyr    s    !#I*9TBCM.yGH}$5 6666' BSSnU3SS=JKE./K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    ra   __sklearn_clone__zLtest_check_estimator_cloneable_error.<locals>.NotCloneable.__sklearn_clone__  s    %&HIIr`   N)r[   r\   r]   r  r_   r`   ra   NotCloneabler    s    	Jr`   r  zCloning of .* failed with errorr  N)r   r(   r  r9   )r  r  r  s      ra   $test_check_estimator_cloneable_errorr    sG    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    ra   __repr__z3test_estimator_repr_error.<locals>.NotRepr.__repr__  s    %&LMMr`   N)r[   r\   r]   r  r_   r`   ra   NotReprr    s    	Nr`   r  zRepr of .* failed with errorr  N)r   r(   r  r:   )r  r  r  s      ra   test_estimator_repr_errorr    sG    N- N 	I
(C	c	* 3Y	23 3 3r  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 re   r_   r  s    ra   
_more_tagszCtest_check_estimator_tags_renamed.<locals>.BadEstimator1._more_tags      r`   N)r[   r\   r]   r  r_   r`   ra   BadEstimator1r        	r`   r  c                       e Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.BadEstimator2c                      y re   r_   r  s    ra   	_get_tagszBtest_check_estimator_tags_renamed.<locals>.BadEstimator2._get_tags  r  r`   N)r[   r\   r]   r  r_   r`   ra   BadEstimator2r    r  r`   r  c                       e Zd Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.OkayEstimatorc                      y re   r_   r  s    ra   rU  zItest_check_estimator_tags_renamed.<locals>.OkayEstimator.__sklearn_tags__  r  r`   c                      y re   r_   r  s    ra   r  zCtest_check_estimator_tags_renamed.<locals>.OkayEstimator._more_tags  r  r`   N)r[   r\   r]   rU  r  r_   r`   ra   OkayEstimatorr    s    		r`   r  z.has defined either `_more_tags` or `_get_tags`r  )r(   r  r=   )r  r  r  r  s       ra   !test_check_estimator_tags_renamedr    s        ;C			% G$_moFG			% G$_moFG !-/BG GG G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 re   r_   rf   s      ra   rj   zItest_check_classifier_not_supporting_multiclass.<locals>.BadEstimator.fit  r  r`   Nr   r_   r`   ra   BadEstimatorr    s    	r`   r  z=The estimator tag `tags.classifier_tags.multi_class` is Falser  N)r   r(   r  r/   r  r  s     ra   /test_check_classifier_not_supporting_multiclassr     sE    }  JC	c	* S2><>RS S Ss	   >Ac                      dD ]=  } 	 t        j                  |        t	               j                  |       }t        |       ? y # t        $ r t        d|  d      w xY w)N)r   polarszLibrary z is not installed)r  )r  
__import__r?  r&   r   
set_outputr8   )libr  s     ra   test_estimator_with_set_outputr     sj    # #	>  % #$//#/>		"#  	>XcU*;<==	>s   AAc                  D    t        t                     } t        |       sJ y)z0Check that checks_generator returns a generator.N)rO   r   r   )all_instance_gen_checkss    ra   test_estimator_checks_generatorr	  ,  s     89K9MN.///r`   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 re   r_   r_   r`   ra   r  zDtest_check_estimator_callback_with_fast_fail_error.<locals>.<lambda>7  s    r`   )r  r  N)r(   r   r8   r   r_   r`   ra   2test_check_estimator_callback_with_fast_fail_errorr  2  s;    	U
 V 	*,gUV V V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 re   r_   rf   s      ra   rj   z0test_check_mixin_order.<locals>.BadEstimator.fit>  r  r`   re   r   r_   r`   ra   r  r  =  s    	r`   r  z8TransformerMixin comes before/left side of BaseEstimatorr  N)r   r   r(   r  reescaperE   r  s     ra   test_check_mixin_orderr  :  sL    }&6  EC	biin	5 :.,.9: : :s   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 rT  rc  rX  s     ra   rU  zYtest_check_positive_only_tag_during_fit.<locals>.RequiresPositiveXBadTag.__sklearn_tags__H  s!    7+-D,1DOO)Kr`   r  r   s   @ra   RequiresPositiveXBadTagr  G  s    	 	r`   r  z5This happens when passing negative input values as X.r  )r\  r(   r  rJ   )r  s    ra   'test_check_positive_only_tag_during_fitr  F  sG    "<  
U
 
 	+%'>'@	

 
 
s	   <A)r  r  r]  rb  r  inspectr   numbersr   r   r  numpyro   scipy.sparsesparser   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   sklearn.utils.fixesrQ   rR   sklearn.utils.metaestimatorsrS   sklearn.utils.multiclassrT   sklearn.utils.validationrU   rV   rW   rX   r   rZ   rc   rv   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r$  r1  r:  rC  rL  r\  rh  rn  rt  rz  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   r$  r&  rI  rS  rY  rn  rp  rs  r[   r}  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r	  r  r  r  r_   r`   ra   <module>r2     su  
  	 
    "    . W W + & 
  , 1 0 " @ @ @ ) ) ) ) ) ) ) ) ) ) )T @ 5 3 J # ##- # M  ] "= 	] 	 "= &( #* #(	#&7 	##] #(#4 , $- $ m *"#$5 "#J   F((- ("4] 4,} 5 "
!1 

!1 
"4 	= 	'] '
&0	L,R9I4"L	F
V<
E6!3H-6,D	N+
\
R

L 
O] 
(XVy
x2
j
: z ?(70"N#L2	+@&3OlA?*
=
3C8S 	#0V	:
r`   