o
    Ti3C                     @  sn  d Z ddlmZ ddlZddlmZmZ ddlmZm	Z	m
Z
mZmZ ddlZddlmZ ddlZddlmZmZmZmZmZ ddlZddlZddlmZ dd	lmZ dd
lmZ ddl m!Z!m"Z" ddl#m$Z$m%Z%m&Z& ddl'm(Z( erddl)m*Z*m+Z+m,Z,m-Z-m.Z. ddl/m0Z0 dd Z1dd Z2dddZ3dd Z4dd Z5dddZ6dd d!Z7dd"d#Z8dd$d%Z9dd'd(Z:e	)ddd/d0Z;eddd3d0Z;ddd4d0Z;	ddd7d8Z<d9d: Z=dd>d?Z>dd@dAZ?ddBdCZ@ddEdFZAddHdIZBdJdK ZCdLdM ZDdNdO ZEeddRdSZFeddVdSZFdddXdSZFdd\d]ZGd^d_ ZHddbdcZIejJ	ddddidjZKddndoZLejMejMejNejOjPejQejRjPiZSejMdpejNdqejQdriZTi ejMdsejNdtejQduejUdvejVdwejMdsejWdsejXdxejYdxejZdyej[dyej\dzej]dzej^d{ej_d{ej`d|ejad|ejNdtejbdtejQduejcduejdd}ejed}ejfd~ejgd~iZhdddZidd ZjdddZkdS )zh
Misc tools for implementing data structures

Note: pandas.core.common is *not* part of the public API.
    )annotationsN)abcdefaultdict)
Collection	GeneratorHashableIterableSequence)partial)TYPE_CHECKINGAnyCallablecastoverload)lib)np_version_gte1p24)'construct_1d_object_array_from_listlike)is_bool_dtype
is_integer)ABCExtensionArrayABCIndex	ABCSeries)iterable_not_string)AnyArrayLike	ArrayLikeNpDtypeRandomStateT)Indexc                 c  s.    | D ]}t |rt|E dH  q|V  qdS )a  
    Flatten an arbitrarily nested sequence.

    Parameters
    ----------
    line : sequence
        The non string sequence to flatten

    Notes
    -----
    This doesn't consider strings sequences.

    Returns
    -------
    flattened : generator
    N)r   flatten)lineelement r"   R/var/www/html/evchargy.com/venv/lib/python3.10/site-packages/pandas/core/common.pyr   =   s   r   c              	   C  sH   | d j }| dd  D ]}z	|j |krd }W q ty!   d }Y qw |S )Nr      )name
ValueError)Zobjsr%   objr"   r"   r#   consensus_name_attrU   s   

r(   keyr   returnboolc                 C  s   t | ttjttfr4| jtjkr+t| }t	
|s)d}t	j
|ddr't|dS dS t| jr2dS dS t | trNt| dkrNt| turIt| } t	| S dS )a  
    Check whether `key` is a valid boolean indexer.

    Parameters
    ----------
    key : Any
        Only list-likes may be considered boolean indexers.
        All other types are not considered a boolean indexer.
        For array-like input, boolean ndarrays or ExtensionArrays
        with ``_is_boolean`` set are considered boolean indexers.

    Returns
    -------
    bool
        Whether `key` is a valid boolean indexer.

    Raises
    ------
    ValueError
        When the array is an object-dtype ndarray or ExtensionArray
        and contains missing values.

    See Also
    --------
    check_array_indexer : Check that `key` is a valid array to index,
        and convert to an ndarray.
    z=Cannot mask with non-boolean array containing NA / NaN valuesT)ZskipnaFr   )
isinstancer   npndarrayr   r   dtypeobject_asarrayr   Zis_bool_arrayr&   r   listlentypeZis_bool_list)r)   Z	key_arrayZna_msgr"   r"   r#   is_bool_indexer`   s$   


	

r5   c                 C  s   t | r|  rtd| S )z
    Disallow indexing with a float key, even if that key is a round number.

    Parameters
    ----------
    val : scalar

    Returns
    -------
    outval : scalar
    zYIndexing with a float is no longer supported. Manually convert to an integer key instead.)r   Zis_floatr   
IndexError)valr"   r"   r#   cast_scalar_indexer   s
   r8   c                  G     dd | D S )zL
    Returns a generator consisting of the arguments that are not None.
    c                 s  s    | ]	}|d ur|V  qd S Nr"   .0argr"   r"   r#   	<genexpr>   s    znot_none.<locals>.<genexpr>r"   argsr"   r"   r#   not_none      rA   c                  G     t dd | D S )z?
    Returns a boolean indicating if any argument is None.
    c                 s      | ]}|d u V  qd S r:   r"   r;   r"   r"   r#   r>          zany_none.<locals>.<genexpr>anyr?   r"   r"   r#   any_none      rH   c                  G  rC   )zA
    Returns a boolean indicating if all arguments are None.
    c                 s  rD   r:   r"   r;   r"   r"   r#   r>      rE   zall_none.<locals>.<genexpr>allr?   r"   r"   r#   all_none   rI   rL   c                  G  rC   )zC
    Returns a boolean indicating if any argument is not None.
    c                 s      | ]}|d uV  qd S r:   r"   r;   r"   r"   r#   r>      rE   zany_not_none.<locals>.<genexpr>rF   r?   r"   r"   r#   any_not_none   rI   rN   c                  G  rC   )zE
    Returns a boolean indicating if all arguments are not None.
    c                 s  rM   r:   r"   r;   r"   r"   r#   r>      rE   zall_not_none.<locals>.<genexpr>rJ   r?   r"   r"   r#   all_not_none   rI   rO   intc                  G  rC   )z;
    Returns the count of arguments that are not None.
    c                 s  rM   r:   r"   r<   xr"   r"   r#   r>      rE   z!count_not_none.<locals>.<genexpr>)sumr?   r"   r"   r#   count_not_none   rI   rT   .valuesArrayLike | list | tuple | zipr/   NpDtype | None
np.ndarrayc                 C     d S r:   r"   rU   r/   r"   r"   r#   asarray_tuplesafe   s   r[   r   r   c                 C  rY   r:   r"   rZ   r"   r"   r#   r[         c                 C  s   t | ttfst| dst| } nt | tr| jS t | tr)|tjtfv r)t	| S z&t
  ts8t
dtj tj| |d}W d    n1 sIw   Y  W n ty\   t	|  Y S w t|jjtrktj| td}|jdkr{dd | D } t	| }|S )NZ	__array__ignorer/      c                 S  s   g | ]}t |qS r"   )tuplerQ   r"   r"   r#   
<listcomp>   s    z%asarray_tuplesafe.<locals>.<listcomp>)r,   r2   r`   hasattrr   Z_valuesr-   r0   objectr   warningscatch_warningsr   simplefilterZVisibleDeprecationWarningr1   r&   
issubclassr/   r4   strndim)rU   r/   resultr"   r"   r#   r[      s,   



labelsnp.ndarray | Iterablec                 C  sZ   t | ttfr
| g} t | ttjfs%zt| } W n ty$   | g} Y nw t| |d} | S )z
    Transform label or iterable of labels to array, for use in Index.

    Parameters
    ----------
    dtype : dtype
        If specified, use as dtype of the resulting array, otherwise infer.

    Returns
    -------
    array
    r^   )r,   rh   r`   r2   r-   r.   	TypeErrorr[   )rk   r/   r"   r"   r#   index_labels_to_array  s   
rn   c                 C  s    | d urt | ttfs| gS | S r:   )r,   r`   r2   r'   r"   r"   r#   maybe_make_list"  s   rp   r'   Iterable[T] | TCollection[T] | Tc                 C  s.   t | tjrt | tjst| S tt| } | S )zB
    If obj is Iterable but not list-like, consume into list.
    )r,   r   r   Sizedr2   r   r   ro   r"   r"   r#   maybe_iterable_to_list(  s   
rt   c                 C  s(   t | to| jdu o| jdu o| jdu S )z
    We have a null slice.
    Nr,   slicestartstopstepro   r"   r"   r#   is_null_slice2     
rz   c                 C  s*   t | to| jduo| jduo| j| jkS )z>
    We have an empty slice, e.g. no values are selected.
    N)r,   rv   rw   rx   ro   r"   r"   r#   is_empty_slice>  s   

r|   
list[bool]c                 C  r9   )zX
    Find non-trivial slices in "line": return a list of booleans with same length.
    c                 S  s    g | ]}t |tot| qS r"   )r,   rv   rz   )r<   kr"   r"   r#   ra   N  s     z"is_true_slices.<locals>.<listcomp>r"   )r    r"   r"   r#   is_true_slicesJ  rB   r   r    c                 C  s(   t | to| jdko| j|ko| jdu S )z&
    We have a full length slice.
    r   Nru   )r'   r    r"   r"   r#   is_full_sliceR  r{   r   c                 C  s>   t | dr
t| dS t| trt| jS t| rt| jS d S )N__name__)	rb   getattrr,   r
   get_callable_namefunccallabler4   r   ro   r"   r"   r#   r   ^  s   




r   c                 K  s   t | r| |fi |S | S )z
    Evaluate possibly callable input using obj and kwargs if it is callable,
    otherwise return as it is.

    Parameters
    ----------
    maybe_callable : possibly a callable
    obj : NDFrame
    **kwargs
    )r   )Zmaybe_callabler'   kwargsr"   r"   r#   apply_if_callableo  s   r   c                 C  sV   t | st| trtt| jS t| } t| tj	s!t
d|  | tkr)t
d| S )a  
    Helper function to standardize a supplied mapping.

    Parameters
    ----------
    into : instance or subclass of collections.abc.Mapping
        Must be a class, an initialized collections.defaultdict,
        or an instance of a collections.abc.Mapping subclass.

    Returns
    -------
    mapping : a collections.abc.Mapping subclass or other constructor
        a callable object that can accept an iterator to create
        the desired Mapping.

    See Also
    --------
    DataFrame.to_dict
    Series.to_dict
    zunsupported type: z/to_dict() only accepts initialized defaultdicts)inspectisclassr,   r   r
   default_factoryr4   rg   r   Mappingrm   )Zintor"   r"   r#   standardize_mapping  s   

r   statenp.random.Generatorc                 C  rY   r:   r"   r   r"   r"   r#   random_state  r\   r   Hint | np.ndarray | np.random.BitGenerator | np.random.RandomState | Nonenp.random.RandomStatec                 C  rY   r:   r"   r   r"   r"   r#   r     s   RandomState | Nonec                 C  sb   t | st| tjtjjfrtj| S t| tjjr| S t| tjjr&| S | du r-tjS td)aq  
    Helper function for processing random_state arguments.

    Parameters
    ----------
    state : int, array-like, BitGenerator, Generator, np.random.RandomState, None.
        If receives an int, array-like, or BitGenerator, passes to
        np.random.RandomState() as seed.
        If receives an np.random RandomState or Generator, just returns that unchanged.
        If receives `None`, returns np.random.
        If receives anything else, raises an informative ValueError.

        Default None.

    Returns
    -------
    np.random.RandomState or np.random.Generator. If state is None, returns np.random

    Nzdrandom_state must be an integer, array-like, a BitGenerator, Generator, a numpy RandomState, or None)	r   r,   r-   r.   randomZBitGeneratorr   r   r&   r   r"   r"   r#   r     s   r   /Callable[..., T] | tuple[Callable[..., T], str]r   c                 O  sX   t |tr!|\}}||v r| d}t|| ||< ||i |S || g|R i |S )as  
    Apply a function ``func`` to object ``obj`` either by passing obj as the
    first argument to the function or, in the case that the func is a tuple,
    interpret the first element of the tuple as a function and pass the obj to
    that function as a keyword argument whose key is the value of the second
    element of the tuple.

    Parameters
    ----------
    func : callable or tuple of (callable, str)
        Function to apply to this object or, alternatively, a
        ``(callable, data_keyword)`` tuple where ``data_keyword`` is a
        string indicating the keyword of ``callable`` that expects the
        object.
    *args : iterable, optional
        Positional arguments passed into ``func``.
    **kwargs : dict, optional
        A dictionary of keyword arguments passed into ``func``.

    Returns
    -------
    object : the return type of ``func``.
    z/ is both the pipe target and a keyword argument)r,   r`   r&   )r'   r   r@   r   targetmsgr"   r"   r#   pipe  s   

r   c                   s$    fdd}t  tjtfr|S  S )zv
    Returns a function that will map names/labels, dependent if mapper
    is a dict, Series or just a function.
    c                   s   |  v r |  S | S r:   r"   )rR   mapperr"   r#   f  s   zget_rename_function.<locals>.f)r,   r   r   r   )r   r   r"   r   r#   get_rename_function  s   r   "Hashable | Iterable | AnyArrayLikelist | AnyArrayLikec                 C  s>   t | ttjtttfr| S t | tjrt | t	st| S | gS )z
    Convert list-like or scalar input to list-like. List, numpy and pandas array-like
    inputs are returned unmodified whereas others are converted to list.
    )
r,   r2   r-   r.   r   r   r   r   r   rh   )rU   r"   r"   r#   convert_to_list_like  s
   r   Tattrrh   	conditionGenerator[None, None, None]c              
   c  sR    |rt | |}t| || z| V  W |rt| || dS dS |r(t| || w w )a~  Temporarily set attribute on an object.

    Args:
        obj: Object whose attribute will be modified.
        attr: Attribute to modify.
        value: Value to temporarily set attribute to.
        condition: Whether to set the attribute. Provided in order to not have to
            conditionally use this context manager.

    Yields:
        obj with modified attribute.
    N)r   setattr)r'   r   valuer   	old_valuer"   r"   r#   temp_setattr  s   
r   indexr   Nonec                 C  s2   t | t |krtdt |  dt | ddS )zC
    Check the length of data matches the length of the index.
    zLength of values (z") does not match length of index ()N)r3   r&   )datar   r"   r"   r#   require_length_match,  s   r   znp.sumznp.maximum.reduceznp.minimum.reducerS   maxminrK   rG   meanprodstdvarmediancumprodcumsumr=   r   
str | Nonec                 C  s
   t | S )zH
    if we define an internal function for this argument, return it
    )_cython_tablegetr=   r"   r"   r#   get_cython_funcf  s   
r   c                 C  s   t | | S )zd
    if we define a builtin function for this argument, return it,
    otherwise return the arg
    )_builtin_tabler   r   r"   r"   r#   is_builtin_funcm  s   r   namesSequence[Hashable | None]list[Hashable]c                 C  s   dd t | D S )a,  
    If a name is missing then replace it by level_n, where n is the count

    .. versionadded:: 1.4.0

    Parameters
    ----------
    names : list-like
        list of column names or None values.

    Returns
    -------
    list
        list of column names with the None values replaced.
    c                 S  s&   g | ]\}}|d u rd| n|qS )NZlevel_r"   )r<   ir%   r"   r"   r#   ra     s   & z&fill_missing_names.<locals>.<listcomp>)	enumerate)r   r"   r"   r#   fill_missing_namesu  s   r   )r)   r   r*   r+   )r*   r+   )r*   rP   ).)rU   rV   r/   rW   r*   rX   )rU   r   r/   rW   r*   r   r:   )rk   rl   r/   rW   r*   rX   )r'   rq   r*   rr   )r*   r}   )r    rP   r*   r+   )r   r   r*   r   )r   r   r*   r   )r   r   )r   r   r*   r   )rU   r   r*   r   )T)r   rh   r   r+   r*   r   )r   r   r*   r   )r=   r   r*   r   )r   r   r*   r   )l__doc__
__future__r   builtinscollectionsr   r   collections.abcr   r   r   r   r	   
contextlib	functoolsr
   r   typingr   r   r   r   r   rd   numpyr-   Zpandas._libsr   Zpandas.compat.numpyr   Zpandas.core.dtypes.castr   Zpandas.core.dtypes.commonr   r   Zpandas.core.dtypes.genericr   r   r   Zpandas.core.dtypes.inferencer   Zpandas._typingr   r   r   r   r   Zpandasr   r   r(   r5   r8   rA   rH   rL   rN   rO   rT   r[   rn   rp   rt   rz   r|   r   r   r   r   r   r   r   r   r   contextmanagerr   r   rS   r   maximumreducer   minimumr   Z_builtin_table_aliasrK   rG   Znansumr   Znanmeanr   Znanprodr   Znanstdr   Znanvarr   Z	nanmedianZnanmaxZnanminr   Z
nancumprodr   Z	nancumsumr   r   r   r   r"   r"   r"   r#   <module>   s    
5




	"





 
#%



	

