
    ri                        d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlmZm	Z	 d dl
Z
d dlZd dlmZ d dlmZmZ d dlmZmZmZmZ d dlmZ d dlmZmZ d dlmZ d d	lm Z m!Z!m"Z" d d
l#m$Z$m%Z%m&Z&m'Z' d dl(m)Z) d dl*m+Z+ d dl,m-Z- d dl.m/Z/m0Z0 d dl1m2Z2m3Z3m4Z4 d dl5m6Z6m7Z7 d dl8m9Z9m:Z: d dl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZA d dlBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZk d dllmmZmmnZn d dlompZp d dlqmrZr d dlsmtZtmuZumvZvmwZw d Zx G d dey      Zz G d dee      Z{ G d de      Z| G d d e      Z} G d! d"e      Z~ G d# d$e      Z G d% d&e      Z G d' d(e      Z G d) d*e      Z G d+ d,e      Z G d- d.e      Z G d/ d0e{      Z G d1 d2e{      Z G d3 d4e{      Z G d5 d6e      Z G d7 d8e{      Z G d9 d:e      Z G d; d<e      Z G d= d>e      Z G d? d@e{      Z G dA dBe      Z G dC dDee      Z G dE dFe      Z G dG dHe'      Z G dI dJe      Z G dK dLe$      Z G dM dNe$      Z G dO dPe%      Z G dQ dRe      Z G dS dTe      ZdU ZdV ZdW ZdX ZdY ZexdZ        Zd[ Zd\ Zd] Zd^ Zd_ Zd` Zda Zdb Zdc Zdd Zexde        Zdf Zdg Zdh Zdi Zdj Zdk Zexdl        Zdm Zdn Zdo Z G dp dqee      Zdr Zds Zdt Zdu Zdv Zexdw        Zedxk(  r e        dy Zdz Zexd{        Zexd|        Zd} Zd~ Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zexd        Zd Zd Zd Zd 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     g/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/sklearn/utils/tests/test_estimator_checks.py&_mark_thread_unsafe_if_pytest_importedrc   l   s4    [[__X&F{{((++    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__ rd   rb   rf   rf   t   s    rd   rf   c                       e Zd Zd Zd Zy)BaseBadClassifierc                     | S Nrk   selfXys      rb   fitzBaseBadClassifier.fit}       rd   c                 F    t        j                  |j                  d         S Nr   nponesshaperq   rr   s     rb   predictzBaseBadClassifier.predict   s    wwqwwqz""rd   Nrg   rh   ri   rt   r}   rk   rd   rb   rm   rm   |   s    #rd   rm   c                   "    e Zd ZddZddZd Zy)ChangesDictc                     || _         y ro   )key)rq   r   s     rb   __init__zChangesDict.__init__   s	    rd   Nc                 &    t        | ||      \  }}| S ro   rY   rp   s      rb   rt   zChangesDict.fit       T1a(1rd   c                 j    t        |      }d| _        t        j                  |j                  d         S )Ni  r   )rV   r   ry   rz   r{   r|   s     rb   r}   zChangesDict.predict   s)    Nwwqwwqz""rd   r   ro   rg   rh   ri   r   rt   r}   rk   rd   rb   r   r      s    #rd   r   c                       e Zd ZddZddZy)SetsWrongAttributec                     || _         y ro   )acceptable_key)rq   r   s     rb   r   zSetsWrongAttribute.__init__   s
    ,rd   Nc                 4    d| _         t        | ||      \  }}| S rw   wrong_attributerY   rp   s      rb   rt   zSetsWrongAttribute.fit   !     T1a(1rd   r   ro   rg   rh   ri   r   rt   rk   rd   rb   r   r      s    -rd   r   c                       e Zd ZddZddZy)ChangesWrongAttributec                     || _         y ro   )r   )rq   r   s     rb   r   zChangesWrongAttribute.__init__   
    .rd   Nc                 4    d| _         t        | ||      \  }}| S N   r   rp   s      rb   rt   zChangesWrongAttribute.fit   r   rd   r   ro   r   rk   rd   rb   r   r      s    /rd   r   c                       e Zd ZddZy)ChangesUnderscoreAttributeNc                 4    d| _         t        | ||      \  }}| S r   )_good_attributerY   rp   s      rb   rt   zChangesUnderscoreAttribute.fit   r   rd   ro   rg   rh   ri   rt   rk   rd   rb   r   r      s    rd   r   c                   .     e Zd ZddZ fdZddZ xZS )RaisesErrorInSetParamsc                     || _         y ro   prq   r   s     rb   r   zRaisesErrorInSetParams.__init__   	    rd   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 0rk   )pop
ValueErrorr   super
set_paramsrq   kwargsr   	__class__s      rb   r   z!RaisesErrorInSetParams.set_params   sD    &=

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

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

3ADFy

3"w!+F++rd   c                 &    t        | ||      \  }}| S ro   r   rp   s      rb   rt   zModifiesAnotherValue.fit   r   rd   )r   method1ro   r   r   s   @rb   r   r      s    ,rd   r   c                       e Zd Zd Zy)NoCheckinPredictc                 &    t        | ||      \  }}| S ro   r   rp   s      rb   rt   zNoCheckinPredict.fit   r   rd   Nr   rk   rd   rb   r   r      s    rd   r   c                        e Zd ZddZd Zd Zy)NoSparseClassifierNc                     || _         y ro   raise_for_typerq   r   s     rb   r   zNoSparseClassifier.__init__   
    ,rd   c                     t        | ||ddg      \  }}| j                  dk(  rt        |t        j                        }n)| j                  dk(  rt        |t        j
                        }rt        d      | S )Ncsrcscaccept_sparsesparse_arraysparse_matrixNonsensical Error)rY   r   
isinstancespsparrayspmatrixr   rq   rr   rs   correct_types       rb   rt   zNoSparseClassifier.fit  sj    T1au~F1.0%a4L  O3%a5L011rd   c                 \    t        |      }t        j                  |j                  d         S rw   rV   ry   rz   r{   r|   s     rb   r}   zNoSparseClassifier.predict  "    Nwwqwwqz""rd   ro   r   rk   rd   rb   r   r      s    -#rd   r   c                       e Zd Zd Zd Zy)CorrectNotFittedErrorClassifierc                 t    t        | ||      \  }}t        j                  |j                  d         | _        | S r   )rY   ry   rz   r{   coef_rp   s      rb   rt   z#CorrectNotFittedErrorClassifier.fit  s1    T1a(1WWQWWQZ(
rd   c                 r    t        |        t        |      }t        j                  |j                  d         S rw   )rW   rV   ry   rz   r{   r|   s     rb   r}   z'CorrectNotFittedErrorClassifier.predict  s*    Nwwqwwqz""rd   Nr~   rk   rd   rb   r   r     s    
#rd   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   )rq   rr   rs   sample_weightr   s        rb   rt   z"NoSampleWeightPandasSeriesType.fit  sD    !Qn4SW
1 	"mV,P  rd   c                 \    t        |      }t        j                  |j                  d         S rw   r   r|   s     rb   r}   z&NoSampleWeightPandasSeriesType.predict,  r   rd   ro   r~   rk   rd   rb   r   r     s    #rd   r   c                       e Zd ZddZd Zy)BadBalancedWeightsClassifierNc                     || _         y ro   )class_weight)rq   r   s     rb   r   z%BadBalancedWeightsClassifier.__init__2  s
    (rd   c                     ddl m} ddlm}  |       j	                  |      }|j
                  } || j                  ||      }| j                  dk(  r|dz  }|| _        | S )Nr   )LabelEncoder)compute_class_weight)classesrs   balanced      ?)sklearn.preprocessingr   sklearn.utilsr   rt   classes_r   r   )rq   rr   rs   r   r   label_encoderr  r   s           rb   rt   z BadBalancedWeightsClassifier.fit5  sb    66$**1-((+D,=,=wRST 
*CL "
rd   ro   r   rk   rd   rb   r   r   1  s    )rd   r   c                       e Zd ZddZd Zy)BadTransformerWithoutMixinNc                     t        | |      }| S ro   r   rp   s      rb   rt   zBadTransformerWithoutMixin.fitH  s    $"rd   c                 8    t        |        t        | |d      }|S )NFreset)rW   rY   r|   s     rb   	transformz$BadTransformerWithoutMixin.transformL  s    $/rd   ro   )rg   rh   ri   rt   r  rk   rd   rb   r	  r	  G  s    rd   r	  c                       e Zd Zd Zd Zy)NotInvariantPredictc                 .    t        | ||ddd      \  }}| S Nr   Tr   r   rp   s      rb   rt   zNotInvariantPredict.fitS  s%    !Qn4SW
1 rd   c                     t        |      }|j                  d   dkD  r"t        j                  |j                  d         S t        j                  |j                  d         S )Nr   r   )rV   r{   ry   rz   zerosr|   s     rb   r}   zNotInvariantPredict.predictZ  sH    N771:>771771:&&xx
##rd   Nr~   rk   rd   rb   r  r  R  s    $rd   r  c                       e Zd Zd Zd Zy)NotInvariantSampleOrderc                 <    t        | ||ddd      \  }}|| _        | S r  )rY   _Xrp   s      rb   rt   zNotInvariantSampleOrder.fitc  s,    !Qn4SW
1 rd   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   ry   array_equivsortr  anyr  r{   r|   s     rb   r}   zNotInvariantSampleOrder.predictk  sm    N NN27711-rwwtwwQ/GHdgg""$88AGGAJ''Awrd   Nr~   rk   rd   rb   r  r  b  s    	rd   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 ro   )raise_when_single_class)rq   r!  s     rb   r   z&OneClassSampleErrorClassifier.__init__{  s
    '>$rd   Nc                    t        ||ddd      \  }}d| _        t        j                  |d      \  | _        }| j                  j
                  d   }|dk  r| j                  rd| _        t        d      |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_ry   uniquer  r{   r!  r   r   ndarraylencount_nonzerobincount)rq   rr   rs   r   
n_classes_s        rb   rt   z!OneClassSampleErrorClassifier.fit~  s    qTT
1 "'99Qt<q]]((+
>d::%)D"122 $-4]9Ka9O--bkk!].KL
A~)-& !455rd   c                     t        |        t        |      }| j                  r"t        j                  |j
                  d         S t        j                  |j
                  d         S rw   )rW   rV   r%  ry   r  r{   rz   r|   s     rb   r}   z%OneClassSampleErrorClassifier.predict  sJ    N!!88AGGAJ''wwqwwqz""rd   )Fro   rg   rh   ri   rj   r   rt   r}   rk   rd   rb   r  r  w  s    #?,#rd   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 ro   r   r   s     rb   r   z*LargeSparseNotSupportedClassifier.__init__  r   rd   c           	         t        | ||dddd      \  }}| j                  dk(  rt        |t        j                        }n)| j                  dk(  rt        |t        j
                        }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   r2  int64z(Estimator doesn't support 64-bit indices)r   r   )rY   r   r   r   r   r   formatrowdtypecolr   indicesindptrr   s       rb   rt   z%LargeSparseNotSupportedClassifier.fit  s    / $
1 .0%a4L  O3%a5Lxx5 55;;')QUU[[G-C$%OPP  ^+IIOOHHNN'  > >> 
 rd   ro   )rg   rh   ri   rj   r   rt   rk   rd   rb   r/  r/    s    /-rd   r/  c                   *    e Zd ZddZddZddZd Zy)SparseTransformerNc                     || _         y ro   sparse_container)rq   r?  s     rb   r   zSparseTransformer.__init__  s
     0rd   c                     t        | |       | S ro   r   rp   s      rb   rt   zSparseTransformer.fit  s    dArd   c                 D    | j                  ||      j                  |      S ro   )rt   r  rp   s      rb   fit_transformzSparseTransformer.fit_transform  s    xx1~''**rd   c                 X    t        |        t        | |dd      }| j                  |      S )NTF)r   r  )rW   rY   r?  r|   s     rb   r  zSparseTransformer.transform  s+    $UC$$Q''rd   ro   )rg   rh   ri   r   rt   rB  r  rk   rd   rb   r<  r<    s    1+(rd   r<  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   rG  r   ilocvalue_rV   ImportError)rq   rr   rs   rG  s       rb   rt   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 rw   )rV   ry   arrayrI  r{   r|   s     rb   r}   z&EstimatorInconsistentForPandas.predict  s-    Nxx
233rd   Nr~   rk   rd   rb   rE  rE    s     4rd   rE  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   rt   r(  r  r   )rq   rr   rs   	coef_initintercept_initr   r   s         rb   rt   zUntaggedBinaryClassifier.fit  s9    Aq)^]Ct}}!;<<rd   c                 t    t         |   ||||       t        | j                        dkD  rt	        d      | S )N)rr   rs   r  r   r$  rP  )r   partial_fitr(  r  r   )rq   rr   rs   r  r   r   s        rb   rT  z$UntaggedBinaryClassifier.partial_fit  s;    a1g]St}}!;<<rd   )NNNNN)rg   rh   ri   rt   rT  r   r   s   @rb   rN  rN    s     rd   rN  c                   (     e Zd Z fdZ fdZ xZS )TaggedBinaryClassifierc                 h    t        |dd      }|dk7  rt        d| d      t        |   ||      S )Nrs   T)
input_nameraise_unknownbinaryzCOnly binary classification is supported. The type of the target is .)rU   r   r   rt   )rq   rr   rs   y_typer   s       rb   rt   zTaggedBinaryClassifier.fit  sJ    cFXXQ   w{1a  rd   c                 F    t         |          }d|j                  _        |S NF)r   __sklearn_tags__classifier_tagsmulti_classrq   tagsr   s     rb   r`  z'TaggedBinaryClassifier.__sklearn_tags__   s#    w')+0(rd   rg   rh   ri   rt   r`  r   r   s   @rb   rW  rW    s    ! rd   rW  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   rt   rq   rr   rs   r   s      rb   rt   zRequiresPositiveXRegressor.fit  sC    T1au4P1E;;=CDDw{1a  rd   c                 h    t         |          }d|j                  _        d|j                  _        |S )NTF)r   r`  
input_tagspositive_onlysparserc  s     rb   r`  z+RequiresPositiveXRegressor.__sklearn_tags__  s-    w')(,%!&rd   re  r   s   @rb   rg  rg    s    ! rd   rg  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 )NTri  r    negative y values not supported!rj  rk  s      rb   rt   zRequiresPositiveYRegressor.fit  sC    T1at$O1F<<>?@@w{1a  rd   c                 F    t         |          }d|j                  _        |S NT)r   r`  target_tagsrn  rc  s     rb   r`  z+RequiresPositiveYRegressor.__sklearn_tags__  s#    w'))-&rd   re  r   s   @rb   rq  rq    s    ! rd   rq  c                   (     e Zd Z fdZ fdZ xZS )PoorScoreLogisticRegressionc                 (    t         |   |      dz   S r   )r   decision_function)rq   rr   r   s     rb   rz  z-PoorScoreLogisticRegression.decision_function$  s    w(+a//rd   c                 F    t         |          }d|j                  _        |S ru  )r   r`  ra  
poor_scorerc  s     rb   r`  z,PoorScoreLogisticRegression.__sklearn_tags__'  s#    w')*.'rd   )rg   rh   ri   rz  r`  r   r   s   @rb   rx  rx  #  s    0 rd   rx  c                       e Zd Zd Zd Zy)PartialFitChecksNamec                      t        | ||       | S ro   r   rp   s      rb   rt   zPartialFitChecksName.fit.  s    dAq!rd   c                 L    t        | d       }t        | |||       d| _        | S )N_fittedr  T)hasattrrY   r  )rq   rr   rs   r  s       rb   rT  z PartialFitChecksName.partial_fit2  s+    D),,dAq.rd   N)rg   rh   ri   rt   rT  rk   rd   rb   r~  r~  -  s    rd   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 ro   rk   rp   s      rb   rt   zBrokenArrayAPI.fit<  ru   rd   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asarrayry   rL  )rq   rr   enabledxp_s        rb   r}   zBrokenArrayAPI.predict?  sD    ,34((+A::i((88I&&rd   N)rg   rh   ri   rj   rt   r}   rk   rd   rb   r  r  9  s    G'rd   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  rk   rd   rb   test_check_array_api_inputr  H  st    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*   ry   rz   r(   	TypeErrorsummay_share_memory)	not_arraymsgs     rb    test_not_an_array_array_functionr  W  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 ro   rk   rp   s      rb   rt   zftest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethod.fite  s    Krd   N)rg   rh   ri   r   rt   rk   rd   rb   $TestEstimatorWithDeprecatedFitMethodr  d  s    	S	T	 
U	rd   r  test)r   rC   )r  s    rb   4test_check_fit_score_takes_y_works_on_deprecated_fitr  `  s    } 
 F$H$JKrd   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    rb   'test_check_estimator_with_class_removedr  l  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    rb   test_mutable_default_paramsr  s  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  rO   r   warningscatch_warningsr   UserWarningcategoryr   )r  recordsrecs      rb   test_check_set_paramsr    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    rb   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   r   r  s    rb   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   rN   r   rJ  )r   r  s     rb   '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    rb   &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    rb   $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)Nr}   zY{method} of {name} is not invariant when applied to a datasetwith different sample order.methodnamer  r  )r  rg   r5  r(   r  rD   r  r  r  s      rb   *test_check_methods_sample_order_invariancer    s\    "++DF	'fFf&  
c	* 
-%'>'@	

 
 
   AA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  rg   r5  r(   r  rE   r  s      rb   $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   rg   r(   r  r<   rS   r;   r/  r  r  s     rb    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  rg   r(   r  r3   r  s     rb   /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     rb   	<genexpr>z5test_check_estimator_not_fail_fast.<locals>.<genexpr>  sC        	4 		
		

		
s   :<c              3   ,   K   | ]  }|d    dk(    yw)r  failedNrk   r  s     rb   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>'       DdtH~)D   c              3   ,   K   | ]  }|d    dk(    yw)r  passedNrk   r  s     rb   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>(  r  r  )r8   r   r   listr(  allr  )check_resultss    rb   "test_check_estimator_not_fail_fastr    s     $MOTBMmT***}!!!  "    DmDDDDDmDDDDrd   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  rP  r>  g{Gz?)Crs  )r(   AttributeErrorr8   r   r   rN  rR   r<  r   r   rW  rg  rq  rx  )r  csr_containers     rb   test_check_estimatorr  .  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  )ry   rL  r(   r  rI   )decisions    rb   test_check_outlier_corruptionr  S  sW    xx,-H		 1 Ax01 xx,-HQ8,	1 1s   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 ro   )
tag_sparser   	fit_error)rq   r  r   r  s       rb   r   zKtest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.__init__b  s    (DO!.D&DNrd   c                 h    | j                   r| j                   t        | ||| j                         | S )Nr   )r  rY   r   rp   s      rb   rt   zFtest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.fitg  s,    ~~nn$$1D4F4FGKrd   c                 Z    t         |          }| j                  |j                  _        |S ro   )r   r`  r  rm  ro  rc  s     rb   r`  zStest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.__sklearn_tags__m  s%    7+-D%)__DOO"Krd   ro   rg   rh   ri   r   rt   r`  r   r   s   @rb   EstimatorWithSparseConfigr  a  s    	'
		 	rd   r  TN)r  r   
error_typeFr  r   r  zunexpected errorzother error)r   r  r=   r   rg   r(   r  KeyError)r  
test_cases	test_caser  r  s        rb   test_check_estimator_sparse_tagr  ]  s?   M $ d$GuDIt>Re>R	J   	T	-l#o&
	 \"*&y':':'C'CYO	,/0 T*9+>+>+G+GST T	T   23Xm5LM P	-eUIF	N# 	P&y':':'C'CYO	P 	PPT T	P 	P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	  rk   rd   rb   )test_check_estimator_transformer_no_mixinr	    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   rQ   joblibhashr8   r"   rt   datatarget)iris	Estimatorestold_hashs       rb   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,	 		 	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  rA   r   r   r  s    rb   test_check_estimators_unfittedr    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 ro   )you_should_not_set_this_rq   s    rb   r   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSet.__init__  s
    ,0D)rd   Nrg   rh   ri   r   rk   rd   rb    NonConformantEstimatorPrivateSetr    s    	1rd   r  c                       e Zd ZddZy)Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSetNc                      y ro   rk   )rq   you_should_set_this_s     rb   r   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSet.__init__  s    rd   ro   r  rk   rd   rb    NonConformantEstimatorNoParamSetr!    s    	rd   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 ro   rk   rp   s      rb   rt   zStest_check_no_attributes_set_in_init.<locals>.ConformantEstimatorClassAttribute.fit      Krd   ro   )rg   rh   ri   9_ConformantEstimatorClassAttribute__metadata_request__fitrt   rk   rd   rb   !ConformantEstimatorClassAttributer&    s    #($-	rd   r+  zEstimator estimator_name should not set any attribute apart from parameters during init. Found attributes \['you_should_not_set_this_'\].r  estimator_namezPEstimator estimator_name should store all parameters as an attribute during initT)enable_metadata_routing)r'  )r   r(   r  rG   r  r   set_fit_request)r  r$  r+  r  s       rb   $test_check_no_attributes_set_in_initr/    s    1= 1= M 	= 
 
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    rb   test_check_estimator_pairwiser4    s2     ]
#CC ]
3CC0KC0PQrd   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.   rE  rk   rd   rb   'test_check_classifier_data_not_an_arrayr7    s3    	&>	? 
*<>	

 
 
   09c                  x    t        t        d      5  t        dt                      d d d        y # 1 sw Y   y xY wr6  )r(   r  rL   rE  rk   rd   rb   &test_check_regressor_data_not_an_arrayr:  
  s3    	&>	? 
)<>	

 
 
r8  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   rm   r~  r   r   rg   rj   )err_msglrs     rb   -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 ro   response_output)rq   rC  s     rb   r   z&_BaseMultiLabelClassifierMock.__init__"  r   rd   c                     | S ro   rk   rp   s      rb   rt   z!_BaseMultiLabelClassifierMock.fit%  ru   rd   c                 F    t         |          }d|j                  _        |S ru  )r   r`  ra  multi_labelrc  s     rb   r`  z._BaseMultiLabelClassifierMock.__sklearn_tags__(  s#    w')+/(rd   r   r   s   @rb   r@  r@  !  s    / rd   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 ro   rB  r|   s     rb   r}   zdtest_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredict.predict<      '''rd   N)rg   rh   ri   r}   rk   rd   rb   MultiLabelClassifierPredictrV  ;      	(rd   rY  rB  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   rg   astypery   float64)	rN  	test_size	n_outputsr  rs   y_testrY  clfr<  s	            rb   7test_check_classifiers_multilabel_output_format_predictrc  .  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)NrH  r$  r  rL  Tr   rM  c                       e Zd Zd Zy)gtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProbac                     | j                   S ro   rB  r|   s     rb   predict_probazutest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProba.predict_probag  rX  rd   N)rg   rh   ri   rh  rk   rd   rb    MultiLabelClassifierPredictProbarf  f  rZ  rd   ri  rB  zUnknown returned type .*zZ.* by MultiLabelClassifierPredictProba.predict_proba. A list or a Numpy array is expected.r  zWhen MultiLabelClassifierPredictProba.predict_proba returns a list, the list should be of length n_outputs and contain NumPy arrays. Got length of z instead of r\  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{   r7  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\).)r7  znWhen MultiLabelClassifierPredictProba.predict_proba returns a NumPy array, the expected data type is floating.r  zWhen MultiLabelClassifierPredictProba.predict_proba returns a NumPy array, this array is expected to provide probabilities of the positive class and should therefore contain values between 0 and 1.)r   r@  rR   rg   r(   r   r2   r   r\  r  rangery   	ones_likerz   r{   r4  r^  
zeros_like)rN  r_  r`  r  rs   ra  ri  r  rb  r<  rC  s              rb   =test_check_classifiers_multilabel_output_format_predict_probarm  Y  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)NrH  r$  r  rL  Tr   rM  c                       e Zd Zd Zy)otest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunctionc                     | j                   S ro   rB  r|   s     rb   rz  ztest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunction.decision_function  rX  rd   N)rg   rh   ri   rz  rk   rd   rb   $MultiLabelClassifierDecisionFunctionrp    rZ  rd   rr  rB  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   r@  r\  r(   r  r0   r   rg   )	rN  r_  r`  r  rs   ra  rr  rb  r<  s	            rb   Atest_check_classifiers_multilabel_output_format_decision_functionrs    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)r\   r]   dir
startswithgetattrunittestFunctionTestCase	TestSuiteaddTestsTextTestRunnerrun)main_moduler  test_functionsfnr  suiterunners          rb   run_tests_without_pytestr  
  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    rb   2test_check_class_weight_balanced_linear_classifierr    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   rg   rx  )r  
estimatorsr  s      rb   test_all_estimators_all_publicr  "  sh     
	 	 	- &#%
& : :==))44S999:	& &s   AA&ru  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          rb   +test_estimator_checks_generator_strict_noner  4  s    
#E*
+C237 (/	F  1$$$ &>1'!W*=Q>M>}!!!& 1"((+
z000001	 ?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
             rb   2test_estimator_checks_generator_strict_xfail_testsr  K  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         rb   .test_estimator_checks_generator_skipping_testsr  k  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  r  )
r   r"   r(  r  r  r8   r  r   r  r   )	r  r  r  logswxfail_warnsr  logxfaileds	            rb   "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   rk   )r  r  r  r  r  r  
call_counts         rb   callbackz/test_check_estimator_callback.<locals>.callback  s$     AAAA6ard   Tr  N)r  r  r  r  r  r  r  r  )r   r"   r(  r  r  r8   r  rP   )r  r  r  all_checks_countr  s       @rb   test_check_estimator_callbackr    s    a1EJ  'C8=%&***		 	 	- 
#9		

 4 :3t LMNg#&<"====h!###h1$$$i :g..H1EE  
 
s   	B>>Cc                      t         ro   )r&   r%   r$   r#   r8   )minimal_estimatorsr  s     rb   (test_minimal_class_implementation_checksr    s	     Nrd   c                       G d dt               } t        t        d      5  t        d | d             d d d        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 ro   behavior)rq   r  s     rb   r   z:test_check_fit_check_is_fitted.<locals>.Estimator.__init__  s	    $DMrd   c                 b    | j                   dk(  r	d| _        | S | j                   dk(  rd| _        | S )N	attributeTr  )r  
is_fitted_
_is_fitted)rq   rr   rs   r   s       rb   rt   z5test_check_fit_check_is_fitted.<locals>.Estimator.fit  s6    }}+"& K (*"&Krd   c                     | j                   dv S )N>   r  always-truer  r  s    rb   <lambda>z:test_check_fit_check_is_fitted.<locals>.Estimator.<lambda>  s    4==4M#M rd   c                 :    | j                   dk(  ryt        | d      S )Nr  Tr  )r  r  r  s    rb   __sklearn_is_fitted__zGtest_check_fit_check_is_fitted.<locals>.Estimator.__sklearn_is_fitted__  s    }}-4..rd   N)r  )rg   rh   ri   r   rt   rT   r  rk   rd   rb   r  r    s'    	%	 
M	N	/ 
O	/rd   r  z'passes check_is_fitted before being fitr  r  r  r  r  r  )r   r(   	ExceptionrB   )r  s    rb   test_check_fit_check_is_fittedr    sc    /M /" 
	!J	K R!+y-/PQR k9h+GHk9k+JK	R Rs   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 ro   )rX   rp   s      rb   rt   z1test_check_requires_y_none.<locals>.Estimator.fit  s    Q?DAqrd   Nr   rk   rd   rb   r  r    s    	#rd   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)rq   rr   rs   ves       rb   rt   z?test_check_requires_y_none.<locals>.EstimatorWithWrongError.fit  sR    	P A1 P 2wQ   !!NOOPs    	;6;Nr   rk   rd   rb   EstimatorWithWrongErrorr    s    
	Prd   r  zxYour estimator raised a ValueError, but with the incorrect or incomplete error message to be considered a graceful fail.r  )r   r  r  rM   messager(   r   )r  r  r   r  r<  s        rb   test_check_requires_y_noner    s    #M # 
	 	 	- 8k9;78 $**a		***P- P	E  

'	* Fk+B+DEF F18 8 +(F F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 ru  )r   r`  non_deterministicrc  s     rb   r`  zQtest_non_deterministic_estimator_skip_tests.<locals>.MyEstimator.__sklearn_tags__  s    w/1)-&rd   rg   rh   ri   r`  r   r   s   @rb   MyEstimatorr    s     rd   r  )r%   r$   r#   r  r+   rD   rE   )r  	all_testsr  s      rb   +test_non_deterministic_estimator_skip_testsr    s     )*:<MN @	*9;tDE	4	AAA.);;;	) 	 *;=FG	4IEEE.i???@rd   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 ro   )contamination)rq   r  s     rb   r   zStest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.__init__  s
    !.Drd   Nc                     | S ro   rk   )rq   rr   rs   r   s       rb   rt   zNtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.fit"  r)  rd   c                 F    t        j                  |j                  d         S rw   rx   rp   s      rb   r}   zRtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.predict%  s    771771:&&rd   )g?rU  ro   r-  rk   rd   rb    OutlierDetectorWithoutConstraintr    s    <	/		'rd   r  Nc                   $    e Zd Zd edh      giZy)Gtest_check_outlier_contamination.<locals>.OutlierDetectorWithConstraintr  autoN)rg   rh   ri   r    _parameter_constraintsrk   rd   rb   OutlierDetectorWithConstraintr  -  s    "1Jx4H3I!Jrd   r  zDcontamination constraints should contain a Real Interval constraint.r  r   g      ?right)closedr  r   r[  r$  leftz<contamination constraint should be an interval in \(0, 0.5\])r
   r   rH   r   rg   r(   r  r   r   r  r   )r  detectorr  r<  incorrect_intervalsintervals         rb    test_check_outlier_contaminationr    s   

'< 
' 0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    rb   test_decision_proba_tie_rankingr  M  s     :.I$_i@rd   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ro   )rg   r  func)r  s    rb   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          rb   test_yield_all_checks_legacyr  W  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    rb   __sklearn_clone__zLtest_check_estimator_cloneable_error.<locals>.NotCloneable.__sklearn_clone__p  s    %&HIIrd   N)rg   rh   ri   r  rk   rd   rb   NotCloneabler  o  s    	Jrd   r  zCloning of .* failed with errorr  N)r   r(   r  r9   )r  r  r  s      rb   $test_check_estimator_cloneable_errorr  l  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    rb   __repr__z3test_estimator_repr_error.<locals>.NotRepr.__repr__}  s    %&LMMrd   N)rg   rh   ri   r  rk   rd   rb   NotReprr  |  s    	Nrd   r  zRepr of .* failed with errorr  N)r   r(   r  r:   )r  r  r  s      rb   test_estimator_repr_errorr  y  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 ro   rk   r  s    rb   
_more_tagszCtest_check_estimator_tags_renamed.<locals>.BadEstimator1._more_tags      rd   N)rg   rh   ri   r  rk   rd   rb   BadEstimator1r        	rd   r  c                       e Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.BadEstimator2c                      y ro   rk   r  s    rb   	_get_tagszBtest_check_estimator_tags_renamed.<locals>.BadEstimator2._get_tags  r  rd   N)rg   rh   ri   r  rk   rd   rb   BadEstimator2r    r  rd   r  c                       e Zd Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.OkayEstimatorc                      y ro   rk   r  s    rb   r`  zItest_check_estimator_tags_renamed.<locals>.OkayEstimator.__sklearn_tags__  r  rd   c                      y ro   rk   r  s    rb   r  zCtest_check_estimator_tags_renamed.<locals>.OkayEstimator._more_tags  r  rd   N)rg   rh   ri   r`  r  rk   rd   rb   OkayEstimatorr    s    		rd   r!  z.has defined either `_more_tags` or `_get_tags`r  )r(   r  r>   )r  r  r!  r  s       rb   !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 ro   rk   rp   s      rb   rt   zItest_check_classifier_not_supporting_multiclass.<locals>.BadEstimator.fit  r)  rd   Nr   rk   rd   rb   BadEstimatorr%    s    	rd   r'  z=The estimator tag `tags.classifier_tags.multi_class` is Falser  N)r   r(   r  r/   r'  r  s     rb   /test_check_classifier_not_supporting_multiclassr)    sE    }  JC	c	* S2><>RS S Ss	   >Ac                      dD ]A  } 	 t        j                  |        t	               j                  |       }t        |ddi       C y # t        $ r t        d|  d      w xY w)N)r   polarszLibrary z is not installed)r  r,   z_this check is expected to fail because pandas and polars are not compatible with the array api.)r  r  )r  
__import__rJ  r&   r   
set_outputr8   )libr  s     rb   test_estimator_with_set_outputr/    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    rb   test_estimator_checks_generatorr2    s     89K9MN.///rd   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 ro   rk   rk   rd   rb   r  zDtest_check_estimator_callback_with_fast_fail_error.<locals>.<lambda>  s    rd   )r  r  N)r(   r   r8   r   rk   rd   rb   2test_check_estimator_callback_with_fast_fail_errorr6    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 ro   rk   rp   s      rb   rt   z0test_check_mixin_order.<locals>.BadEstimator.fit  r)  rd   ro   r   rk   rd   rb   r'  r9    s    	rd   r'  z8TransformerMixin comes before/left side of BaseEstimatorr  N)r   r   r(   r  reescaperF   r(  s     rb   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 r_  )r   r`  rm  rn  rc  s     rb   r`  zYtest_check_positive_only_tag_during_fit.<locals>.RequiresPositiveXBadTag.__sklearn_tags__  s!    7+-D,1DOO)Krd   r  r   s   @rb   RequiresPositiveXBadTagr@    s    	 	rd   rB  z5This happens when passing negative input values as X.r  )rg  r(   r  rK   )rB  s    rb   'test_check_positive_only_tag_during_fitrC    sG    "<  
U
 
 	+%'>'@	

 
 
s	   <A)r  r;  r\   rz  r  inspectr   numbersr   r   r  numpyry   scipy.sparsero  r   sklearnr   r   sklearn.baser   r	   r
   r   sklearn.clusterr   sklearn.datasetsr   r   sklearn.decompositionr   sklearn.exceptionsr   r   r   sklearn.linear_modelr   r   r   r   sklearn.mixturer   sklearn.neighborsr   r  r   sklearn.svmr   r   r  r   r   r   sklearn.utils._param_validationr   r    -sklearn.utils._test_common.instance_generatorr!   r"   sklearn.utils._testingr#   r$   r%   r&   r'   r(   sklearn.utils.estimator_checksr)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   sklearn.utils.fixesrR   rS   sklearn.utils.metaestimatorsrT   sklearn.utils.multiclassrU   sklearn.utils.validationrV   rW   rX   rY   rc   r   rf   rm   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r	  r  r  r  r/  r<  rE  rN  rW  rg  rq  rx  r~  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r	  r  r  r/  r4  r7  r:  r>  r@  rc  rm  rs  r  r  r  rg   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r"  r)  r/  r2  r6  r=  rC  rk   rd   rb   <module>rZ     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< (!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  (
 (
(0V	:
rd   