
    rh                     T   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  G d dex      Zy G d de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-e      Z G d. d/ez      Z G d0 d1ez      Z G d2 d3ez      Z G d4 d5e      Z G d6 d7ez      Z G d8 d9e      Z G d: d;e      Z G d< d=e      Z G d> d?ez      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 Zdn Z G do dpee      Zdq Zdr Zds Zdt Zdu Zdv Zedwk(  r e        dx Zdy Zdz Zd{ 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_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                       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/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/sklearn/utils/tests/test_estimator_checks.pyr[   r[   l   s    ra   r[   c                       e Zd Zd Zd Zy)BaseBadClassifierc                     | S Nr`   selfXys      rb   fitzBaseBadClassifier.fitu       ra   c                 F    t        j                  |j                  d         S Nr   nponesshaperh   ri   s     rb   predictzBaseBadClassifier.predictx   s    wwqwwqz""ra   Nr\   r]   r^   rk   rt   r`   ra   rb   rd   rd   t   s    #ra   rd   c                   "    e Zd ZddZddZd Zy)ChangesDictc                     || _         y rf   )key)rh   ry   s     rb   __init__zChangesDict.__init__}   s	    ra   Nc                 &    t        | ||      \  }}| S rf   rY   rg   s      rb   rk   zChangesDict.fit       T1a(1ra   c                 j    t        |      }d| _        t        j                  |j                  d         S )Ni  r   )rV   ry   rp   rq   rr   rs   s     rb   rt   zChangesDict.predict   s)    Nwwqwwqz""ra   r   rf   r\   r]   r^   rz   rk   rt   r`   ra   rb   rw   rw   |   s    #ra   rw   c                       e Zd ZddZddZy)SetsWrongAttributec                     || _         y rf   )acceptable_key)rh   r   s     rb   rz   zSetsWrongAttribute.__init__   s
    ,ra   Nc                 4    d| _         t        | ||      \  }}| S rn   wrong_attributerY   rg   s      rb   rk   zSetsWrongAttribute.fit   !     T1a(1ra   r   rf   r\   r]   r^   rz   rk   r`   ra   rb   r   r      s    -ra   r   c                       e Zd ZddZddZy)ChangesWrongAttributec                     || _         y rf   )r   )rh   r   s     rb   rz   zChangesWrongAttribute.__init__   
    .ra   Nc                 4    d| _         t        | ||      \  }}| S N   r   rg   s      rb   rk   zChangesWrongAttribute.fit   r   ra   r   rf   r   r`   ra   rb   r   r      s    /ra   r   c                       e Zd ZddZy)ChangesUnderscoreAttributeNc                 4    d| _         t        | ||      \  }}| S r   )_good_attributerY   rg   s      rb   rk   zChangesUnderscoreAttribute.fit   r   ra   rf   r\   r]   r^   rk   r`   ra   rb   r   r      s    ra   r   c                   .     e Zd ZddZ fdZddZ xZS )RaisesErrorInSetParamsc                     || _         y rf   prh   r   s     rb   rz   zRaisesErrorInSetParams.__init__   	    ra   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rh   kwargsr   	__class__s      rb   r   z!RaisesErrorInSetParams.set_params   sD    &=

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

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

3ADFy

3"w!+F++ra   c                 &    t        | ||      \  }}| S rf   r|   rg   s      rb   rk   zModifiesAnotherValue.fit   r}   ra   )r   method1rf   r   r   s   @rb   r   r      s    ,ra   r   c                       e Zd Zd Zy)NoCheckinPredictc                 &    t        | ||      \  }}| S rf   r|   rg   s      rb   rk   zNoCheckinPredict.fit   r}   ra   Nr   r`   ra   rb   r   r      s    ra   r   c                        e Zd ZddZd Zd Zy)NoSparseClassifierNc                     || _         y rf   raise_for_typerh   r   s     rb   rz   zNoSparseClassifier.__init__   
    ,ra   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   rh   ri   rj   correct_types       rb   rk   zNoSparseClassifier.fit   sj    T1au~F1.0%a4L  O3%a5L011ra   c                 \    t        |      }t        j                  |j                  d         S rn   rV   rp   rq   rr   rs   s     rb   rt   zNoSparseClassifier.predict  "    Nwwqwwqz""ra   rf   r   r`   ra   rb   r   r      s    -#ra   r   c                       e Zd Zd Zd Zy)CorrectNotFittedErrorClassifierc                 t    t        | ||      \  }}t        j                  |j                  d         | _        | S r   )rY   rp   rq   rr   coef_rg   s      rb   rk   z#CorrectNotFittedErrorClassifier.fit
  s1    T1a(1WWQWWQZ(
ra   c                 r    t        |        t        |      }t        j                  |j                  d         S rn   )rW   rV   rp   rq   rr   rs   s     rb   rt   z'CorrectNotFittedErrorClassifier.predict  s*    Nwwqwwqz""ra   Nru   r`   ra   rb   r   r   	  s    
#ra   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   )rh   ri   rj   sample_weightr   s        rb   rk   z"NoSampleWeightPandasSeriesType.fit  sD    !Qn4SW
1 	"mV,P  ra   c                 \    t        |      }t        j                  |j                  d         S rn   r   rs   s     rb   rt   z&NoSampleWeightPandasSeriesType.predict$  r   ra   rf   ru   r`   ra   rb   r   r     s    #ra   r   c                       e Zd ZddZd Zy)BadBalancedWeightsClassifierNc                     || _         y rf   )class_weight)rh   r   s     rb   rz   z%BadBalancedWeightsClassifier.__init__*  s
    (ra   c                     ddl m} ddlm}  |       j	                  |      }|j
                  } || j                  ||      }| j                  dk(  r|dz  }|| _        | S )Nr   )LabelEncoder)compute_class_weight)classesrj   balanced      ?)sklearn.preprocessingr   sklearn.utilsr   rk   classes_r   r   )rh   ri   rj   r   r   label_encoderr   r   s           rb   rk   z BadBalancedWeightsClassifier.fit-  sb    66$**1-((+D,=,=wRST 
*CL "
ra   rf   r   r`   ra   rb   r   r   )  s    )ra   r   c                       e Zd ZddZd Zy)BadTransformerWithoutMixinNc                     t        | |      }| S rf   r|   rg   s      rb   rk   zBadTransformerWithoutMixin.fit@  s    $"ra   c                 8    t        |        t        | |d      }|S )NFreset)rW   rY   rs   s     rb   	transformz$BadTransformerWithoutMixin.transformD  s    $/ra   rf   )r\   r]   r^   rk   r  r`   ra   rb   r   r   ?  s    ra   r   c                       e Zd Zd Zd Zy)NotInvariantPredictc                 .    t        | ||ddd      \  }}| S Nr   Tr   r|   rg   s      rb   rk   zNotInvariantPredict.fitK  s%    !Qn4SW
1 ra   c                     t        |      }|j                  d   dkD  r"t        j                  |j                  d         S t        j                  |j                  d         S )Nr   r   )rV   rr   rp   rq   zerosrs   s     rb   rt   zNotInvariantPredict.predictR  sH    N771:>771771:&&xx
##ra   Nru   r`   ra   rb   r  r  J  s    $ra   r  c                       e Zd Zd Zd Zy)NotInvariantSampleOrderc                 <    t        | ||ddd      \  }}|| _        | S r	  )rY   _Xrg   s      rb   rk   zNotInvariantSampleOrder.fit[  s,    !Qn4SW
1 ra   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   rp   array_equivsortr  anyr  rr   rs   s     rb   rt   zNotInvariantSampleOrder.predictc  sm    N NN27711-rwwtwwQ/GHdgg""$88AGGAJ''Awra   Nru   r`   ra   rb   r  r  Z  s    	ra   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 rf   )raise_when_single_class)rh   r  s     rb   rz   z&OneClassSampleErrorClassifier.__init__s  s
    '>$ra   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_rp   uniquer   rr   r  r   r   ndarraylencount_nonzerobincount)rh   ri   rj   r   
n_classes_s        rb   rk   z!OneClassSampleErrorClassifier.fitv  s    qTT
1 "'99Qt<q]]((+
>d::%)D"122 $-4]9Ka9O--bkk!].KL
A~)-& !455ra   c                     t        |        t        |      }| j                  r"t        j                  |j
                  d         S t        j                  |j
                  d         S rn   )rW   rV   r  rp   r  rr   rq   rs   s     rb   rt   z%OneClassSampleErrorClassifier.predict  sJ    N!!88AGGAJ''wwqwwqz""ra   )Frf   r\   r]   r^   r_   rz   rk   rt   r`   ra   rb   r  r  o  s    #?,#ra   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 rf   r   r   s     rb   rz   z*LargeSparseNotSupportedClassifier.__init__  r   ra   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   )rY   r   r   r   r   r   formatrowdtypecolr   indicesindptrr   s       rb   rk   z%LargeSparseNotSupportedClassifier.fit  s    / $
1 .0%a4L  O3%a5Lxx5 55;;')QUU[[G-C$%OPP  ^+IIOOHHNN'  > >> 
 ra   rf   )r\   r]   r^   r_   rz   rk   r`   ra   rb   r&  r&    s    /-ra   r&  c                   *    e Zd ZddZddZddZd Zy)SparseTransformerNc                     || _         y rf   sparse_container)rh   r6  s     rb   rz   zSparseTransformer.__init__  s
     0ra   c                     t        | |       | S rf   r|   rg   s      rb   rk   zSparseTransformer.fit  s    dAra   c                 D    | j                  ||      j                  |      S rf   )rk   r  rg   s      rb   fit_transformzSparseTransformer.fit_transform  s    xx1~''**ra   c                 X    t        |        t        | |dd      }| j                  |      S )NTF)r   r  )rW   rY   r6  rs   s     rb   r  zSparseTransformer.transform  s+    $UC$$Q''ra   rf   )r\   r]   r^   rz   rk   r9  r  r`   ra   rb   r3  r3    s    1+(ra   r3  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_rV   ImportError)rh   ri   rj   r>  s       rb   rk   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 rn   )rV   rp   arrayr@  rr   rs   s     rb   rt   z&EstimatorInconsistentForPandas.predict  s-    Nxx
233ra   Nru   r`   ra   rb   r<  r<    s     4ra   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   rk   r  r   r   )rh   ri   rj   	coef_initintercept_initr   r   s         rb   rk   zUntaggedBinaryClassifier.fit  s9    Aq)^]Ct}}!;<<ra   c                 t    t         |   ||||       t        | j                        dkD  rt	        d      | S )N)ri   rj   r   r   r  rG  )r   partial_fitr  r   r   )rh   ri   rj   r   r   r   s        rb   rK  z$UntaggedBinaryClassifier.partial_fit  s;    a1g]St}}!;<<ra   )NNNNN)r\   r]   r^   rk   rK  r   r   s   @rb   rE  rE    s     ra   rE  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 )Nrj   T)
input_nameraise_unknownbinaryzCOnly binary classification is supported. The type of the target is .)rU   r   r   rk   )rh   ri   rj   y_typer   s       rb   rk   zTaggedBinaryClassifier.fit  sJ    cFXXQ   w{1a  ra   c                 F    t         |          }d|j                  _        |S NF)r   __sklearn_tags__classifier_tagsmulti_classrh   tagsr   s     rb   rW  z'TaggedBinaryClassifier.__sklearn_tags__  s#    w')+0(ra   r\   r]   r^   rk   rW  r   r   s   @rb   rN  rN    s    ! ra   rN  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   rk   rh   ri   rj   r   s      rb   rk   zRequiresPositiveXRegressor.fit  sC    T1au4P1E;;=CDDw{1a  ra   c                 h    t         |          }d|j                  _        d|j                  _        |S )NTF)r   rW  
input_tagspositive_onlysparserZ  s     rb   rW  z+RequiresPositiveXRegressor.__sklearn_tags__  s-    w')(,%!&ra   r\  r   s   @rb   r^  r^    s    ! ra   r^  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 )NTr`  r    negative y values not supported!ra  rb  s      rb   rk   zRequiresPositiveYRegressor.fit  sC    T1at$O1F<<>?@@w{1a  ra   c                 F    t         |          }d|j                  _        |S NT)r   rW  target_tagsre  rZ  s     rb   rW  z+RequiresPositiveYRegressor.__sklearn_tags__  s#    w'))-&ra   r\  r   s   @rb   rh  rh    s    ! ra   rh  c                   (     e Zd Z fdZ fdZ xZS )PoorScoreLogisticRegressionc                 (    t         |   |      dz   S r   )r   decision_function)rh   ri   r   s     rb   rq  z-PoorScoreLogisticRegression.decision_function  s    w(+a//ra   c                 F    t         |          }d|j                  _        |S rl  )r   rW  rX  
poor_scorerZ  s     rb   rW  z,PoorScoreLogisticRegression.__sklearn_tags__  s#    w')*.'ra   )r\   r]   r^   rq  rW  r   r   s   @rb   ro  ro    s    0 ra   ro  c                       e Zd Zd Zd Zy)PartialFitChecksNamec                      t        | ||       | S rf   r|   rg   s      rb   rk   zPartialFitChecksName.fit&  s    dAq!ra   c                 L    t        | d       }t        | |||       d| _        | S )N_fittedr  T)hasattrrY   rx  )rh   ri   rj   r  s       rb   rK  z PartialFitChecksName.partial_fit*  s+    D),,dAq.ra   N)r\   r]   r^   rk   rK  r`   ra   rb   ru  ru  %  s    ra   ru  c                       e Zd ZdZd Zd Zy)BrokenArrayAPIz=Make different predictions when using Numpy and the Array APIc                     | S rf   r`   rg   s      rb   rk   zBrokenArrayAPI.fit4  rl   ra   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asarrayrp   rC  )rh   ri   enabledxp_s        rb   rt   zBrokenArrayAPI.predict7  sD    ,34((+A::i((88I&&ra   N)r\   r]   r^   r_   rk   rt   r`   ra   rb   r{  r{  1  s    G'ra   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{  r`   ra   rb   test_check_array_api_inputr  @  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*   rp   rq   r(   	TypeErrorsummay_share_memory)	not_arraymsgs     rb    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 rf   r`   rg   s      rb   rk   zftest_check_fit_score_takes_y_works_on_deprecated_fit.<locals>.TestEstimatorWithDeprecatedFitMethod.fit]  s    Kra   N)r\   r]   r^   r   rk   r`   ra   rb   $TestEstimatorWithDeprecatedFitMethodr  \  s    	S	T	 
U	ra   r  test)r   rC   )r  s    rb   4test_check_fit_score_takes_y_works_on_deprecated_fitr  X  s    } 
 F$H$JKra   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  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)rJ   r   r(   r  r   r  s    rb   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  rO   r   warningscatch_warningsr   UserWarningcategoryr   )r  recordsrecs      rb   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    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   rw   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   rA  )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)Nrt   zY{method} of {name} is not invariant when applied to a datasetwith different sample order.methodnamer  r  )r  r\   r,  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)Nrt   z={method} of {name} is not invariant when applied to a subset.r  r  r  )r  r\   r,  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   r\   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  r\   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  failedNr`   r  s     rb   r  z5test_check_estimator_not_fail_fast.<locals>.<genexpr>       DdtH~)D   c              3   ,   K   | ]  }|d    dk(    yw)r  passedNr`   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Dra   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  rG  r5  g{Gz?)Crj  )r(   AttributeErrorr8   r   r   rE  rR   r3  r   r   rN  r^  rh  ro  )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  )rp   rC  r(   r  rI   )decisions    rb   test_check_outlier_corruptionr  F  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 rf   )
tag_sparser   	fit_error)rh   r  r   r  s       rb   rz   zKtest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.__init__U  s    (DO!.D&DNra   c                 h    | j                   r| j                   t        | ||| j                         | S )Nr   )r  rY   r   rg   s      rb   rk   zFtest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.fitZ  s,    ~~nn$$1D4F4FGKra   c                 Z    t         |          }| j                  |j                  _        |S rf   )r   rW  r  rd  rf  rZ  s     rb   rW  zStest_check_estimator_sparse_tag.<locals>.EstimatorWithSparseConfig.__sklearn_tags__`  s%    7+-D%)__DOO"Kra   rf   r\   r]   r^   rz   rk   rW  r   r   s   @rb   EstimatorWithSparseConfigr  T  s    	'
		 	ra   r  TN)r  r   
error_typeFr  r   r  zunexpected errorzother error)r   r  r=   r   r\   r(   r  KeyError)r  
test_cases	test_caser  r  s        rb   test_check_estimator_sparse_tagr  P  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   r`   ra   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"   rk   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 rf   )you_should_not_set_this_rh   s    rb   rz   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorPrivateSet.__init__  s
    ,0D)ra   Nr\   r]   r^   rz   r`   ra   rb    NonConformantEstimatorPrivateSetr    s    	1ra   r  c                       e Zd ZddZy)Ntest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSetNc                      y rf   r`   )rh   you_should_set_this_s     rb   rz   zWtest_check_no_attributes_set_in_init.<locals>.NonConformantEstimatorNoParamSet.__init__  s    ra   rf   r  r`   ra   rb    NonConformantEstimatorNoParamSetr    s    	ra   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`   ra   rb   !ConformantEstimatorClassAttributer    s    #($-ra   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= 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    rb   test_check_estimator_pairwiser)    s2    
 ]
#CC ]
3CC0KC0PQra   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`   ra   rb   '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  rL   r<  r`   ra   rb   &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   rd   ru  r   r   r\   r_   )err_msglrs     rb   -test_check_dataframe_column_names_consistencyr3    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 rf   response_output)rh   r8  s     rb   rz   z&_BaseMultiLabelClassifierMock.__init__  r   ra   c                     | S rf   r`   rg   s      rb   rk   z!_BaseMultiLabelClassifierMock.fit  rl   ra   c                 F    t         |          }d|j                  _        |S rl  )r   rW  rX  multi_labelrZ  s     rb   rW  z._BaseMultiLabelClassifierMock.__sklearn_tags__  s#    w')+/(ra   r  r   s   @rb   r5  r5    s    / ra   r5  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 rf   r7  rs   s     rb   rt   zdtest_check_classifiers_multilabel_output_format_predict.<locals>.MultiLabelClassifierPredict.predict(      '''ra   N)r\   r]   r^   rt   r`   ra   rb   MultiLabelClassifierPredictrK  '      	(ra   rN  r7  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   r5  tolistr(   r  r1   r   r\   astyperp   float64)	rC  	test_size	n_outputsr  rj   y_testrN  clfr1  s	            rb   7test_check_classifiers_multilabel_output_format_predictrX    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  rA  Tr   rB  c                       e Zd Zd Zy)gtest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProbac                     | j                   S rf   r7  rs   s     rb   predict_probazutest_check_classifiers_multilabel_output_format_predict_proba.<locals>.MultiLabelClassifierPredictProba.predict_probaS  rM  ra   N)r\   r]   r^   r]  r`   ra   rb    MultiLabelClassifierPredictProbar[  R  rO  ra   r^  r7  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 rS  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\).)rr   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 1rP  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   r5  rR   r\   r(   r   r2   r   rQ  r  rangerp   	ones_likerq   rr   r+  rS  
zeros_like)rC  rT  rU  r  rj   rV  r^  r  rW  r1  r8  s              rb   =test_check_classifiers_multilabel_output_format_predict_probarb  E  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  rA  Tr   rB  c                       e Zd Zd Zy)otest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunctionc                     | j                   S rf   r7  rs   s     rb   rq  ztest_check_classifiers_multilabel_output_format_decision_function.<locals>.MultiLabelClassifierDecisionFunction.decision_function  rM  ra   N)r\   r]   r^   rq  r`   ra   rb   $MultiLabelClassifierDecisionFunctionre    rO  ra   rg  r7  zwMultiLabelClassifierDecisionFunction.decision_function is expected to output a NumPy array. Got <class 'list'> instead.r  rP  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   r5  rQ  r(   r  r0   r   r\   )	rC  rT  rU  r  rj   rV  rg  rW  r1  s	            rb   Atest_check_classifiers_multilabel_output_format_decision_functionrh    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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   r\   ro  )r  
estimatorsr
  s      rb   test_all_estimators_all_publicr    sh     
	 	 	- &#%
& : :==))44S999:	& &s   AA&rj  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"   rP   r  r&   appendr)   r  r  )r
  r  checksskipped_checksr  checks         rb   .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	            rb   "test_xfail_count_with_no_fast_failr  3  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         rb   callbackz/test_check_estimator_callback.<locals>.callbackO  s$     AAAA6ara   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  K  s    a1EJ  'C8=%&***		 	 	- 
#9		

 4 :3t LMNg#&<"====h!###h1$$$i :g..H1EE  
 
s   	B>>Cc                      t         rf   )r&   r%   r$   r#   r8   )minimal_estimatorsr  s     rb   (test_minimal_class_implementation_checksr  r  s	     Nra   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 rf   behavior)rh   r  s     rb   rz   z:test_check_fit_check_is_fitted.<locals>.Estimator.__init__~  s	    $DMra   c                 b    | j                   dk(  r	d| _        | S | j                   dk(  rd| _        | S )N	attributeTr  )r  
is_fitted_
_is_fitted)rh   ri   rj   r   s       rb   rk   z5test_check_fit_check_is_fitted.<locals>.Estimator.fit  s6    }}+"& K (*"&Kra   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 ra   c                 :    | j                   dk(  ryt        | d      S )Nr  Tr  )r  ry  r  s    rb   __sklearn_is_fitted__zGtest_check_fit_check_is_fitted.<locals>.Estimator.__sklearn_is_fitted__  s    }}-4..ra   N)r  )r\   r]   r^   rz   rk   rT   r  r`   ra   rb   r	  r  }  s'    	%	 
M	N	/ 
O	/ra   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                       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 rf   )rX   rg   s      rb   rk   z1test_check_requires_y_none.<locals>.Estimator.fit  s    Q?DAqra   Nr   r`   ra   rb   r	  r    s    	#ra   r	  Tr  r  )r   r  r  rM   message)r	  r  r   s      rb   test_check_requires_y_noner    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 rl  )r   rW  non_deterministicrZ  s     rb   rW  zQtest_non_deterministic_estimator_skip_tests.<locals>.MyEstimator.__sklearn_tags__  s    w/1)-&ra   r\   r]   r^   rW  r   r   s   @rb   MyEstimatorr    s     ra   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???@ra   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 rf   )contamination)rh   r  s     rb   rz   zStest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.__init__  s
    !.Dra   Nc                     | S rf   r`   )rh   ri   rj   r   s       rb   rk   zNtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.fit      Kra   c                 F    t        j                  |j                  d         S rn   ro   rg   s      rb   rt   zRtest_check_outlier_contamination.<locals>.OutlierDetectorWithoutConstraint.predict  s    771771:&&ra   )g?rL  rf   r$  r`   ra   rb    OutlierDetectorWithoutConstraintr    s    <	/		'ra   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`   ra   rb   OutlierDetectorWithConstraintr    s    "1Jx4H3I!Jra   r  zDcontamination constraints should contain a Real Interval constraint.r  r   g      ?right)closedr  r   rP  r  leftz<contamination constraint should be an interval in \(0, 0.5\])r
   r   rH   r   r\   r(   r  r   r   r  r   )r  detectorr  r1  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    s     :.I$_i@ra   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rf   )r\   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    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__  s    %&HIIra   N)r\   r]   r^   r  r`   ra   rb   NotCloneabler    s    	Jra   r  zCloning of .* failed with errorr  N)r   r(   r  r9   )r  r  r  s      rb   $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    rb   __repr__z3test_estimator_repr_error.<locals>.NotRepr.__repr__  s    %&LMMra   N)r\   r]   r^   r  r`   ra   rb   NotReprr    s    	Nra   r  zRepr of .* failed with errorr  N)r   r(   r  r:   )r  r  r  s      rb   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 rf   r`   r  s    rb   
_more_tagszCtest_check_estimator_tags_renamed.<locals>.BadEstimator1._more_tags%      ra   N)r\   r]   r^   r  r`   ra   rb   BadEstimator1r  $      	ra   r  c                       e Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.BadEstimator2c                      y rf   r`   r  s    rb   	_get_tagszBtest_check_estimator_tags_renamed.<locals>.BadEstimator2._get_tags)  r  ra   N)r\   r]   r^   r   r`   ra   rb   BadEstimator2r  (  r  ra   r  c                       e Zd Zd Zd Zy)8test_check_estimator_tags_renamed.<locals>.OkayEstimatorc                      y rf   r`   r  s    rb   rW  zItest_check_estimator_tags_renamed.<locals>.OkayEstimator.__sklearn_tags__-  r  ra   c                      y rf   r`   r  s    rb   r  zCtest_check_estimator_tags_renamed.<locals>.OkayEstimator._more_tags0  r  ra   N)r\   r]   r^   rW  r  r`   ra   rb   OkayEstimatorr  ,  s    		ra   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 rf   r`   rg   s      rb   rk   zItest_check_classifier_not_supporting_multiclass.<locals>.BadEstimator.fitF  r  ra   Nr   r`   ra   rb   BadEstimatorr
  C  s    	ra   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 ]=  } 	 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__rA  r&   r   
set_outputr8   )libr  s     rb   test_estimator_with_set_outputr  O  sj    # #	>  % #$//#/>		"#  	>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_generatorr  [  s     89K9MN.///ra   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 rf   r`   r`   ra   rb   r  zDtest_check_estimator_callback_with_fast_fail_error.<locals>.<lambda>f  s    ra   )r  r  N)r(   r   r8   r   r`   ra   rb   2test_check_estimator_callback_with_fast_fail_errorr  a  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 rf   r`   rg   s      rb   rk   z0test_check_mixin_order.<locals>.BadEstimator.fitm  r  ra   rf   r   r`   ra   rb   r  r  l  s    	ra   r  z8TransformerMixin comes before/left side of BaseEstimatorr  N)r   r   r(   r  reescaperF   r  s     rb   test_check_mixin_orderr"  i  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 rV  )r   rW  rd  re  rZ  s     rb   rW  zYtest_check_positive_only_tag_during_fit.<locals>.RequiresPositiveXBadTag.__sklearn_tags__w  s!    7+-D,1DOO)Kra   r  r   s   @rb   RequiresPositiveXBadTagr%  v  s    	 	ra   r'  z5This happens when passing negative input values as X.r  )r^  r(   r  rK   )r'  s    rb   'test_check_positive_only_tag_during_fitr(  u  sG    "<  
U
 
 	+%'>'@	

 
 
s	   <A)r  r   rl  rq  r  inspectr   numbersr   r   r  numpyrp   scipy.sparserf  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   r   r[   rd   rw   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r&  r3  r<  rE  rN  r^  rh  ro  ru  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/  r3  r5  rX  rb  rh  r|  r~  r  r\   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r"  r(  r`   ra   rb   <module>r?     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I4"L	F
V<
E6!3H-,P^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	:
ra   