
    `VgN(                    l   d 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mZ ddlmZ ddlmZmZ ddlmZmZ dd	lmZmZmZmZmZ erdd
lmZmZmZm Z m!Z! dZ"	 	 	 	 	 	 ddZ#dde"df	 	 	 	 	 	 	 	 	 	 	 ddZ$de"f	 	 	 	 	 	 	 ddZ%	 	 	 	 	 	 	 	 ddZ&de"df	 	 	 	 	 	 	 	 	 ddZ'de"df	 	 	 	 	 	 	 	 	 ddZ(y)z"
data hash pandas / numpy objects
    )annotationsN)TYPE_CHECKINGHashableIterableIteratorcast)lib)hash_object_array)	ArrayLikenpt)is_categorical_dtypeis_list_like)ABCDataFrameABCExtensionArrayABCIndexABCMultiIndex	ABCSeries)Categorical	DataFrameIndex
MultiIndexSeries0123456789123456c                   	 t        |       }t        j                  |g|       } t        j                  d      }t        j                  |      t        j                  d      z   }t        |       D ]2  \  }}||z
  }||z  }||z  }|t        j                  d|z   |z         z  }4 dz   |k(  sJ d       |t        j                  d      z  }|S # t        $ r( t        j                  g t        j                        cY S w xY w)z
    Parameters
    ----------
    arrays : Iterator[np.ndarray]
    num_items : int

    Returns
    -------
    np.ndarray[uint64]

    Should be the same as CPython's tupleobject.c
    dtypeiCB ixV4 iXB    zFed in wrong num_itemsi| )	nextStopIterationnparrayuint64	itertoolschain
zeros_like	enumerate)arrays	num_itemsfirstmultoutia	inverse_is           Y/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/pandas/core/util/hashing.pycombine_hash_arraysr0   2   s    -V __eWf-F99WD
--
8!4
4C&! 91M	qt		%)+i788	9
 q5I777299UCJ  -xx")),,-s   C .C>=C>Tutf8c                f    ddl m} t        t         t              r |t               dd      S t         t              r7t         j                        j                  dd      } || dd      }|S t         t              rtt         j                        j                  dd      }|r1 fdd	D        }t        j                  |g|      }	t        |	d
      } || j                  dd      }|S t         t              rfd j!                         D        }
t#         j$                        }|r2 fdd	D        }|dz  }t        j                  |
|      }d |D        }
t        |
|      } || j                  dd      }|S t'        dt)                      )a~  
    Return a data hash of the Index/Series/DataFrame.

    Parameters
    ----------
    obj : Index, Series, or DataFrame
    index : bool, default True
        Include the index in the hash (if Series/DataFrame).
    encoding : str, default 'utf8'
        Encoding for data & key when strings.
    hash_key : str, default _default_hash_key
        Hash_key for string key to encode.
    categorize : bool, default True
        Whether to first categorize object arrays before hashing. This is more
        efficient when the array contains duplicate values.

    Returns
    -------
    Series of uint64, same length as the object
    r   )r   r"   F)r   copyr3   )indexr   r3   c              3  f   K   | ](  }t        j                  d       j                   * ywF)r5   encodinghash_key
categorizeNhash_pandas_objectr5   _values.0_r:   r8   r9   objs     r/   	<genexpr>z%hash_pandas_object.<locals>.<genexpr>   s?      	  #II%%) '	   .1N   c              3  T   K   | ]  \  }}t        |j                         ! y wrD   )
hash_arrayr=   )r?   r@   seriesr:   r8   r9   s      r/   rB   z%hash_pandas_object.<locals>.<genexpr>   s,      
6 v~~x:F
s   %(c              3  f   K   | ](  }t        j                  d       j                   * ywr7   r;   r>   s     r/   rB   z%hash_pandas_object.<locals>.<genexpr>   s?      	$  #II%%) '	$rC   r   c              3      K   | ]  }|  y wrD    )r?   xs     r/   rB   z%hash_pandas_object.<locals>.<genexpr>   s     )Aa)s   zUnexpected type for hashing )pandasr   _default_hash_key
isinstancer   hash_tuplesr   rG   r=   astyper   r#   r$   r0   r5   r   itemslencolumns	TypeErrortype)rA   r5   r8   r9   r:   r   hser
index_iterr'   hashesr(   index_hash_generator_hashess   ` ```         r/   r<   r<   T   s   6 $#}%k#x:(QVWW	C	"s{{Hh
CJJ5 K 
 Qc>d Ja 
C	#s{{Hh
CJJ5 K 
 	  	J __aS*5F#FA.AQciixeD< J9 
C	&
 YY[
 $		$  	$  NI  oof.BCG))F	2QciixeD J 6tCykBCC    c           	     h   t        |       st        d      ddlm}m} t        | t              s |j                  |       }n| }t        |j                        D cg c](  } ||j                  |   |j                  |   dd      * }}fd|D        }t        |t        |            }	|	S c c}w )a  
    Hash an MultiIndex / listlike-of-tuples efficiently.

    Parameters
    ----------
    vals : MultiIndex or listlike-of-tuples
    encoding : str, default 'utf8'
    hash_key : str, default _default_hash_key

    Returns
    -------
    ndarray[np.uint64] of hashed values
    z'must be convertible to a list-of-tuplesr   )r   r   FTorderedfastpathc              3  :   K   | ]  }t        |         yw))r8   r9   N)_hash_categorical)r?   catr8   r9   s     r/   rB   zhash_tuples.<locals>.<genexpr>   s#      IL#8DDs   )r   rU   rM   r   r   rO   r   from_tuplesrangenlevelscodeslevelsr0   rS   )
valsr8   r9   r   r   milevelcat_valsrZ   rW   s
    ``       r/   rP   rP      s    $ ABB
 dM*#Z##D)
 2::& 	BHHUORYYu%5utTH PXF 	FCM2AHs   -B/c                j   t        j                  | j                  j                        }t	        |||d      }| j                         }t        |      r|j                  | j                        }n t        j                  t        |      d      }|j                         rt        j                  ||<   |S )a  
    Hash a Categorical by hashing its categories, and then mapping the codes
    to the hashes

    Parameters
    ----------
    cat : Categorical
    encoding : str
    hash_key : str

    Returns
    -------
    ndarray[np.uint64] of hashed values, same size as len(c)
    F)r:   r"   r   )r    asarray
categoriesr=   rG   isnarS   takerh   zerosanyr	   u8max)rd   r8   r9   valueshashedmaskresults          r/   rc   rc      s    $ ZZ../F(uEF 88:D
6{SYY'#d)84xxzyytMr]   c                l   t        | d      st        d      | j                  }t        |      rt	        d|       } t        | ||      S t        | t              r| j                         \  } }n<t        | t        j                        s"t        dt        |       j                   d      t        | |||      S )aK  
    Given a 1d array, return an array of deterministic integers.

    Parameters
    ----------
    vals : ndarray or ExtensionArray
    encoding : str, default 'utf8'
        Encoding for data & key when strings.
    hash_key : str, default _default_hash_key
        Hash_key for string key to encode.
    categorize : bool, default True
        Whether to first categorize object arrays before hashing. This is more
        efficient when the array contains duplicate values.

    Returns
    -------
    ndarray[np.uint64, ndim=1]
        Hashed values, same length as the vals.
    r   zmust pass a ndarray-liker   z6hash_array requires np.ndarray or ExtensionArray, not z!. Use hash_pandas_object instead.)hasattrrU   r   r   r   rc   rO   r   _values_for_factorizer    ndarrayrV   __name___hash_ndarray)rj   r8   r9   r:   r   r@   s         r/   rG   rG     s    2 4!233JJE
 E"M4( x::	D+	,,,.abjj)DDz""##DF
 	

 x:>>r]   c                V   | j                   }t        j                  |t        j                        r@t	        t        j
                  |             dt	        t        j                  |             z  z   S |t        k(  r| j                  d      } nt        |j                  t        j                  t        j                  f      r#| j                  d      j                  dd      } nt        |j                  t        j                        rG|j                  dk  r8| j                  d| j                   j                         j                  d      } nP|r@dd	lm}m}m}  || d
      \  }}	 || |j(                  |	      dd      }
t+        |
||      S 	 t-        | ||      } | | dz	  z  } | t        j4                  d      z  } | | dz	  z  } | t        j4                  d      z  } | | dz	  z  } | S # t.        $ r6 t-        | j                  t0              j                  t2              ||      } Y w xY w)z!
    See hash_array.__doc__.
       u8i8Fr4      ur   )r   r   	factorize)sortTr_      l   e9z    l   b&&&	    )r   r    
issubdtype
complex128rG   realimagboolrQ   
issubclassrV   
datetime64timedelta64viewnumberitemsizerM   r   r   r   _with_inferrc   r
   rU   strobjectr"   )rj   r8   r9   r:   r   r   r   r   rh   rp   rd   s              r/   r   r   7  s    JJE 
}}UBMM*"''$-(2
2774=0I+III 
${{4 	EJJ ?	@yy%%d%7	EJJ			*u~~/Byy1TZZ00123::4@
   !*$U ;E:(u((4edC %S(H==	$T8X>D 	DBJDBII())DDBJDBII())DDBJDK  	$C ''/8D	s   G) )<H('H()r'   zIterator[np.ndarray]r(   intreturnnpt.NDArray[np.uint64])rA   zIndex | DataFrame | Seriesr5   r   r8   r   r9   z
str | Noner:   r   r   r   )rj   z+MultiIndex | Iterable[tuple[Hashable, ...]]r8   r   r9   r   r   r   )rd   r   r8   r   r9   r   r   r   )
rj   r   r8   r   r9   r   r:   r   r   r   )
rj   z
np.ndarrayr8   r   r9   r   r:   r   r   r   ))__doc__
__future__r   r#   typingr   r   r   r   r   numpyr    pandas._libsr	   pandas._libs.hashingr
   pandas._typingr   r   pandas.core.dtypes.commonr   r   pandas.core.dtypes.genericr   r   r   r   r   rM   r   r   r   r   r   rN   r0   r<   rP   rc   rG   r   rK   r]   r/   <module>r      s   #     2
    '  -0H ,Y	#YY Y 	Y
 Y Y| %+
5++ + 	+\%	% #%/2%%T %	.?
.?.? .? 	.?
 .?f %	7
77 7 	7
 7r]   