
     hj+                         d dl ZddlmZmZ ddlmZmZmZ ddlm	Z	  G d d          Z
 G d	 d
          Z G d dee          Z G d de          ZdS )    N   )BaseEstimatorClassifierMixin   )_check_sample_weight_num_samplescheck_array)check_is_fittedc                       e Zd ZdZd Zd ZdS )ArraySlicingWrapper-
    Parameters
    ----------
    array
    c                     || _         d S Narrayselfr   s     R/var/www/html/Sam_Eipo/venv/lib/python3.11/site-packages/sklearn/utils/_mocking.py__init__zArraySlicingWrapper.__init__   s    


    c                 6    t          | j        |                   S r   MockDataFramer   )r   aslices     r   __getitem__zArraySlicingWrapper.__getitem__   s    TZ/000r   N)__name__
__module____qualname____doc__r   r    r   r   r   r      s<           1 1 1 1 1r   r   c                   :    e Zd ZdZd Zd Zd
dZd Zd Zdd	Z	dS )r   r   c                 z    || _         || _        |j        | _        |j        | _        t	          |          | _        d S r   )r   valuesshapendimr   ilocr   s     r   r   zMockDataFrame.__init__   s5    
[
J	'..			r   c                 *    t          | j                  S r   )lenr   r   s    r   __len__zMockDataFrame.__len__'   s    4:r   Nc                     | j         S r   r   )r   dtypes     r   	__array__zMockDataFrame.__array__*   s     zr   c                 <    t          | j        |j        k              S r   r   r   others     r   __eq__zMockDataFrame.__eq__0   s    TZ5;6777r   c                     | |k     S r   r    r/   s     r   __ne__zMockDataFrame.__ne__3   s    5=  r   r   c                 T    t          | j                            ||                    S )N)axis)r   r   take)r   indicesr5   s      r   r6   zMockDataFrame.take6   s"    TZ__W4_@@AAAr   r   )r   )
r   r   r   r   r   r*   r-   r1   r3   r6   r    r   r   r   r      s         / / /     8 8 8! ! !B B B B B Br   r   c            	       \    e Zd ZdZddddddddddZddZdd	Zd
 Zd Zd Z	ddZ
d ZdS )CheckingClassifiera  Dummy classifier to test pipelining and meta-estimators.

    Checks some property of `X` and `y`in fit / predict.
    This allows testing whether pipelines / cross-validation or metaestimators
    changed the input.

    Can also be used to check if `fit_params` are passed correctly, and
    to force a certain score to be returned.

    Parameters
    ----------
    check_y, check_X : callable, default=None
        The callable used to validate `X` and `y`. These callable should return
        a bool where `False` will trigger an `AssertionError`.

    check_y_params, check_X_params : dict, default=None
        The optional parameters to pass to `check_X` and `check_y`.

    methods_to_check : "all" or list of str, default="all"
        The methods in which the checks should be applied. By default,
        all checks will be done on all methods (`fit`, `predict`,
        `predict_proba`, `decision_function` and `score`).

    foo_param : int, default=0
        A `foo` param. When `foo > 1`, the output of :meth:`score` will be 1
        otherwise it is 0.

    expected_sample_weight : bool, default=False
        Whether to check if a valid `sample_weight` was passed to `fit`.

    expected_fit_params : list of str, default=None
        A list of the expected parameters given when calling `fit`.

    Attributes
    ----------
    classes_ : int
        The classes seen during `fit`.

    n_features_in_ : int
        The number of features seen during `fit`.

    Examples
    --------
    >>> from sklearn.utils._mocking import CheckingClassifier

    This helper allow to assert to specificities regarding `X` or `y`. In this
    case we expect `check_X` or `check_y` to return a boolean.

    >>> from sklearn.datasets import load_iris
    >>> X, y = load_iris(return_X_y=True)
    >>> clf = CheckingClassifier(check_X=lambda x: x.shape == (150, 4))
    >>> clf.fit(X, y)
    CheckingClassifier(...)

    We can also provide a check which might raise an error. In this case, we
    expect `check_X` to return `X` and `check_y` to return `y`.

    >>> from sklearn.utils import check_array
    >>> clf = CheckingClassifier(check_X=check_array)
    >>> clf.fit(X, y)
    CheckingClassifier(...)
    Nallr   check_ycheck_y_paramscheck_Xcheck_X_paramsmethods_to_check	foo_paramexpected_sample_weightexpected_fit_paramsc                v    || _         || _        || _        || _        || _        || _        || _        || _        d S r   r;   )	r   r<   r=   r>   r?   r@   rA   rB   rC   s	            r   r   zCheckingClassifier.__init__z   sG     ,, 0"&<##6   r   Tc                 d   |rt          |            | j        F| j        i n| j        } | j        |fi |}t          |t          t
          j        f          r|sJ n|}|M| j        F| j        i n| j        } | j        |fi |}t          |t          t
          j        f          r|sJ n|}||fS )a  Validate X and y and make extra check.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            The data set.
        y : array-like of shape (n_samples), default=None
            The corresponding target, by default None.
        should_be_fitted : bool, default=True
            Whether or not the classifier should be already fitted.
            By default True.

        Returns
        -------
        X, y
        )	r
   r>   r?   
isinstanceboolnpbool_r<   r=   )r   Xyshould_be_fittedparams	checked_X	checked_ys          r   
_check_X_yzCheckingClassifier._check_X_y   s    "  	"D!!!<#.6RRD<OF$Q11&11I)dBH%566    y =T\5.6RRD<OF$Q11&11I)dBH%566    y !tr   c                    t          |          t          |          k    sJ | j        dk    s	d| j        v r|                     ||d          \  }}t          j        |          d         | _        t          j        t          |dd                    | _        | j	        rt          | j	                  t          |          z
  }|r t          dt          |           d	          |                                D ]X\  }}t          |          t          |          k    r3t          d
| dt          |           dt          |           d          Y| j        r!|t          d          t          ||           | S )a   Fit classifier.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            Training vector, where `n_samples` is the number of samples and
            `n_features` is the number of features.

        y : array-like of shape (n_samples, n_outputs) or (n_samples,),                 default=None
            Target relative to X for classification or regression;
            None for unsupervised learning.

        sample_weight : array-like of shape (n_samples,), default=None
            Sample weights. If None, then samples are equally weighted.

        **fit_params : dict of string -> object
            Parameters passed to the ``fit`` method of the estimator

        Returns
        -------
        self
        r:   fitF)rL   r   T)	ensure_2dallow_ndzExpected fit parameter(s) z
 not seen.zFit parameter z has length z; expected .Nz#Expected sample_weight to be passed)r   r@   rP   rH   r$   n_features_in_uniquer	   classes_rC   setAssertionErrorlistitemsrB   r   )r   rJ   rK   sample_weight
fit_paramsmissingkeyvalues           r   rR   zCheckingClassifier.fit   s   0 A,q//1111 E))Ud6K-K-K??1a%?@@DAq hqkk!n	+a54"P"P"PQQ# 	$233c*ooEG $JgJJJ   )..00  
U&&,q//99(9 9 9,u:M:M 9 9&21oo9 9 9   :
 & 	3$$%JKKK 222r   c                     | j         dk    s	d| j         v r|                     |          \  }}| j        t          j        t          |          t                             S )a>  Predict the first class seen in `classes_`.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            The input data.

        Returns
        -------
        preds : ndarray of shape (n_samples,)
            Predictions of the first class seens in `classes_`.
        r:   predict)r,   )r@   rP   rX   rH   zerosr   intr   rJ   rK   s      r   rc   zCheckingClassifier.predict   sV      E))Y$:O-O-O??1%%DAq}RXl1ooSAAABBr   c                     | j         dk    s	d| j         v r|                     |          \  }}t          j        t	          |          t          | j                  f          }d|dddf<   |S )a  Predict probabilities for each class.

        Here, the dummy classifier will provide a probability of 1 for the
        first class of `classes_` and 0 otherwise.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            The input data.

        Returns
        -------
        proba : ndarray of shape (n_samples, n_classes)
            The probabilities for each sample and class.
        r:   predict_probar   Nr   )r@   rP   rH   rd   r   r(   rX   )r   rJ   rK   probas       r   rh   z CheckingClassifier.predict_proba   sn       E))_@U-U-U??1%%DAq,q//3t}+=+=>??aaadr   c                 L   | j         dk    s	d| j         v r|                     |          \  }}t          | j                  dk    r!t	          j        t          |                    S t	          j        t          |          t          | j                  f          }d|dddf<   |S )aB  Confidence score.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            The input data.

        Returns
        -------
        decision : ndarray of shape (n_samples,) if n_classes == 2                else (n_samples, n_classes)
            Confidence score.
        r:   decision_functionr   r   Nr   )r@   rP   r(   rX   rH   rd   r   )r   rJ   rK   decisions       r   rk   z$CheckingClassifier.decision_function	  s     !U**"d&;;;??1%%DAqt}"" 8LOO,,,xa#dm2D2D EFFHHQQQTNOr   c                 z    | j         dk    s	d| j         v r|                     ||           | j        dk    rd}nd}|S )aQ  Fake score.

        Parameters
        ----------
        X : array-like of shape (n_samples, n_features)
            Input data, where `n_samples` is the number of samples and
            `n_features` is the number of features.

        Y : array-like of shape (n_samples, n_output) or (n_samples,)
            Target relative to X for classification or regression;
            None for unsupervised learning.

        Returns
        -------
        score : float
            Either 0 or 1 depending of `foo_param` (i.e. `foo_param > 1 =>
            score=1` otherwise `score=0`).
        r:   scorer   g      ?g        )r@   rP   rA   )r   rJ   Yrn   s       r   rn   zCheckingClassifier.score%  sQ    &  E))W8M-M-MOOAq!!!>AEEEr   c                     ddgdS )NT1dlabel)
_skip_testX_typesr    r)   s    r   
_more_tagszCheckingClassifier._more_tags@  s    "	{;;;r   )NTr   )NN)r   r   r   r   r   rP   rR   rc   rh   rk   rn   rt   r    r   r   r9   r9   :   s        = =D # 7 7 7 7 7*! ! ! !F. . . .`C C C"  ,  8   6< < < < <r   r9   c                   2    e Zd ZdZddZd Zd Zd Zd ZdS )	NoSampleWeightWrapperzWrap estimator which will not expose `sample_weight`.

    Parameters
    ----------
    est : estimator, default=None
        The estimator to wrap.
    Nc                     || _         d S r   )est)r   rx   s     r   r   zNoSampleWeightWrapper.__init__M  s    r   c                 8    | j                             ||          S r   )rx   rR   rf   s      r   rR   zNoSampleWeightWrapper.fitP  s    x||Aq!!!r   c                 6    | j                             |          S r   )rx   rc   r   rJ   s     r   rc   zNoSampleWeightWrapper.predictS  s    x"""r   c                 6    | j                             |          S r   )rx   rh   r{   s     r   rh   z#NoSampleWeightWrapper.predict_probaV  s    x%%a(((r   c                 
    ddiS )Nrr   Tr    r)   s    r   rt   z NoSampleWeightWrapper._more_tagsY  s    d##r   r   )	r   r   r   r   r   rR   rc   rh   rt   r    r   r   rv   rv   D  sn            " " "# # #) ) )$ $ $ $ $r   rv   )numpyrH   baser   r   
validationr   r   r	   r
   r   r   r9   rv   r    r   r   <module>r      s       1 1 1 1 1 1 1 1 G G G G G G G G G G ' ' ' ' ' '1 1 1 1 1 1 1 1!B !B !B !B !B !B !B !BHG< G< G< G< G<- G< G< G<T$ $ $ $ $M $ $ $ $ $r   