
     	iD                    B   d dl mZ d dlmZm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 d dlmZ d dlZd d	lmZm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 m!Z!m"Z" erd dlm#Z# ej$        ej%        ej&        ej'        ej(        ej)        ej)        dZ*ej&        ej+        dfej)        ej,        e
fej$        ej-        dfej%        ej-        dfej'        ej-        dfej.        ej,        dfej(        ej/        d fiZ0ej-        dej+        dej,        diZ1 G d de          Z2dS )    )annotations)TYPE_CHECKINGAnyN)infer_dtype)iNaT)NoBufferPresent)cache_readonly)BaseMaskedDtype)
ArrowDtypeDatetimeTZDtype)is_string_dtype)PandasBufferPandasBufferPyarrow)ColumnColumnBuffersColumnNullType	DtypeKind)ArrowCTypes
Endiannessdtype_to_arrow_c_fmt)Buffer)iufbUMmzThis column is non-nullablezThis column uses NaN as nullz!This column uses a sentinel valuec                      e Zd ZdZd"d#d	Zd$dZed$d            Zed%d            Z	d%dZ
ed             Zed             Zed$d            Zed&d            Zd$dZd'd(dZd)dZd*dZd+dZd,d!ZdS )-PandasColumna  
    A column object, with only the methods and properties required by the
    interchange protocol defined.
    A column can contain one or more chunks. Each chunk can contain up to three
    buffers - a data buffer, a mask buffer (depending on null representation),
    and an offsets buffer (if variable-size binary; e.g., variable-length
    strings).
    Note: this Column object can only be produced by ``__dataframe__``, so
          doesn't need its own version or ``__column__`` protocol.
    Tcolumn	pd.Series
allow_copyboolreturnNonec                    t          |t          j                  rt          d|j         d          t          |t          j                  s t          dt          |           d          || _        || _	        dS )zu
        Note: doesn't deal with extension arrays yet, just assume a regular
        Series/ndarray for now.
        zExpected a Series, got a DataFrame. This likely happened because you called __dataframe__ on a DataFrame which, after converting column names to string, resulted in duplicated names: zD. Please rename these columns before using the interchange protocol.zColumns of type  not handled yetN)

isinstancepd	DataFrame	TypeErrorcolumnsSeriesNotImplementedErrortype_col_allow_copy)selfr"   r$   s      V/srv/django_bis/venv311/lib/python3.11/site-packages/pandas/core/interchange/column.py__init__zPandasColumn.__init__T   s    
 fbl++ 	2 !.2 2 2   &"),, 	Y%&Wf&W&W&WXXX 	%    intc                    | j         j        S )z2
        Size of the column, in elements.
        )r2   sizer4   s    r5   r:   zPandasColumn.sizeh   s     y~r7   c                    dS )z7
        Offset of first element. Always zero.
        r    r;   s    r5   offsetzPandasColumn.offsetn   s	     qr7   tuple[DtypeKind, int, str, str]c                   | j         j        }t          |t          j                  rJ| j         j        j        }|                     |j                  \  }}}}t          j	        ||t          j        fS t          |          rLt          | j                   dv r't          j        dt          |          t          j        fS t!          d          |                     |          S )N)stringempty   z.Non-string object dtypes are not supported yet)r2   dtyper*   r+   CategoricalDtypevaluescodes_dtype_from_pandasdtyper   CATEGORICALr   NATIVEr   r   STRINGr   r0   )r4   rD   rG   _bitwidthc_arrow_dtype_f_strs         r5   rD   zPandasColumn.dtypev   s    	eR011 	7I$*E ,,U[99# %#!	  U## 
	749%%)<<<$(//%	  &&VWWW//666r7   c                   t                               |j        d          }|t          d| d          t	          |t
                    r|j        j        }nKt	          |t                    r|j	        j        }n)t	          |t                    r|j        j        }n|j        }|dk    r||j        t          j        |fS ||j        dz  t          |          |fS )z/
        See `self.dtype` for details.
        N
Data type z& not supported by interchange protocolzbool[pyarrow]rC   )	_NP_KINDSgetkind
ValueErrorr*   r   numpy_dtype	byteorderr   baser
   itemsizer   BOOLr   )r4   rD   rS   rV   s       r5   rH   z$PandasColumn._dtype_from_pandasdtype   s     }}UZ..<W%WWWXXXeZ(( 	()3II// 	(
,II// 	()3IIIO##  	  U^a')=e)D)DiOOr7   c                    | j         d         t          j        k    st          d          | j        j        j        dt          t          j	        | j        j        j
                            dS )a:  
        If the dtype is categorical, there are two options:
        - There are only values in the data buffer.
        - There is a separate non-categorical Column encoding for categorical values.

        Raises TypeError if the dtype is not categorical

        Content of returned dict:
            - "is_ordered" : bool, whether the ordering of dictionary indices is
                             semantically meaningful.
            - "is_dictionary" : bool, whether a dictionary-style mapping of
                                categorical values to other objects exists
            - "categories" : Column representing the (implicit) mapping of indices to
                             category values (e.g. an array of cat1, cat2, ...).
                             None if not a dictionary-style categorical.
        r   zCdescribe_categorical only works on a column with categorical dtype!T)
is_orderedis_dictionary
categories)rD   r   rI   r-   r2   catorderedr!   r+   r/   r]   r;   s    r5   describe_categoricalz!PandasColumn.describe_categorical   sg    $ z!}	 555U  
 )-/!&ry1I'J'JKK
 
 	
r7   c                   t          | j        j        t                    rt          j        }d}||fS t          | j        j        t                    rP| j        j        j        j	        d         
                                d         t          j        d fS t          j        dfS | j        d         }	 t          |         \  }}n!# t          $ r t          d| d          w xY w||fS )N   r   rP   z not yet supported)r*   r2   rD   r
   r   USE_BYTEMASKr   array	_pa_arraychunksbuffersNON_NULLABLEUSE_BITMASK_NULL_DESCRIPTIONKeyErrorr0   )r4   column_null_dtype
null_valuerS   nullvalues         r5   describe_nullzPandasColumn.describe_null   s    dio77 	1 . ;J$j00dioz22 	1 y(/2::<<Q?G%2D88!-q00z!}	M+D1KD%% 	M 	M 	M%&K4&K&K&KLLL	M U{s   /C   Cc                |    | j                                                                                                         S )zB
        Number of null elements. Should always be known.
        )r2   isnasumitemr;   s    r5   
null_countzPandasColumn.null_count   s.    
 y~~##%%**,,,r7   dict[str, pd.Index]c                    d| j         j        iS )z8
        Store specific metadata of the column.
        zpandas.index)r2   indexr;   s    r5   metadatazPandasColumn.metadata   s    
 	00r7   c                    dS )zE
        Return the number of chunks the column consists of.
        rb   r=   r;   s    r5   
num_chunkszPandasColumn.num_chunks   s	     qr7   Nn_chunks
int | Nonec              #     K   |rr|dk    rlt          | j                  }||z  }||z  dk    r|dz  }t          d||z  |          D ].}t          | j        j        |||z            | j                  V  /dS | V  dS )zy
        Return an iterator yielding the chunks.
        See `DataFrame.get_chunks` for details on ``n_chunks``.
        rb   r   N)lenr2   ranger!   ilocr3   )r4   r|   r:   stepstarts        r5   
get_chunkszPandasColumn.get_chunks   s      
  
	1ty>>D8#Dh!##	q$/488  "IN554<#78$:J      
 JJJJJr7   r   c                    |                                  ddd}	 |                                 |d<   n# t          $ r Y nw xY w	 |                                 |d<   n# t          $ r Y nw xY w|S )a`  
        Return a dictionary containing the underlying buffers.
        The returned dictionary has the following contents:
            - "data": a two-element tuple whose first element is a buffer
                      containing the data and whose second element is the data
                      buffer's associated dtype.
            - "validity": a two-element tuple whose first element is a buffer
                          containing mask values indicating missing data and
                          whose second element is the mask value buffer's
                          associated dtype. None if the null representation is
                          not a bit or byte mask.
            - "offsets": a two-element tuple whose first element is a buffer
                         containing the offset values for variable-size binary
                         data (e.g., variable-length strings) and whose second
                         element is the offsets buffer's associated dtype. None
                         if the data buffer does not have an associated offsets
                         buffer.
        N)datavalidityoffsetsr   r   )_get_data_buffer_get_validity_bufferr   _get_offsets_buffer)r4   rg   s     r5   get_bufferszPandasColumn.get_buffers  s    ( ))++"
 "
	"&";";"="=GJ 	 	 	D		!%!9!9!;!;GI 	 	 	D	 s   2 
??A 
A('A(.tuple[Buffer, tuple[DtypeKind, int, str, str]]c                J   | j         d         t          j        t          j        t          j        t          j        t          j        fv r/| j         }| j         d         t          j        k    rPt          | j         d                   dk    r2| j        j	        
                    d                                          }n| j        j        }t          | j        j         t                    r|j        }nrt          | j        j         t                     rL|j        j        d         }t'          |                                d         t          |                    }||fS |j        }t-          || j                  }n*| j         d         t          j        k    rB| j        j        j        }t-          || j                  }|                     |j                   }n| j         d         t          j        k    r| j                                        }t;                      }|D ]@}t          |t<                    r)|                    |                     d	                     At-          tC          j"        |d
                    }| j         }ntG          d| j        j          d          ||fS )zZ
        Return the buffer containing the data and the buffer's associated dtype.
        r         Nrb   length)r$   utf-8encodinguint8)rD   rP   r)   )$rD   r   INTUINTFLOATrY   DATETIMEr   r2   dt
tz_convertto_numpyrd   r*   r
   _datar   re   rf   r   rg   _ndarrayr   r3   rI   rF   _codesrH   rK   	bytearraystrextendencodenp
frombufferr0   )	r4   rD   np_arrarrbufferrG   bufr   objs	            r5   r   zPandasColumn._get_data_buffer0  sH    :a=MNON
 
 
 JEz!}	 222s4:a=7I7IA7M7M0066??AAiodio?? * YFF	<< 
* -.q1C0a("3xx  F "5=( \F!&T5EFFFFFZ]i333I$+E!%D4DEEEF00==EEZ]i...)$$&&CA  ; ;c3'' ;HHSZZZ99::: ""-"A"A"ABBF
 JEE%&T49?&T&T&TUUUu}r7   tuple[Buffer, Any] | Nonec                p   | j         \  }}t          | j        j        t                    r| j        j        j        j        d         }t          j	        dt          j	        t          j        f}|                                d         dS t          |                                d         t          |                    }||fS t          | j        j        t                     rH| j        j        j        }t%          |          }t          j	        dt          j	        t          j        f}||fS | j        d         t          j        k    r| j                                        }|dk    }| }t+          j        t          |          ft*          j                  }t1          |          D ]!\  }	}
t          |
t2                    r|n|||	<   "t%          |          }t          j	        dt          j	        t          j        f}||fS 	 t4          |          d}n# t6          $ r t9          d          w xY wt;          |          )	z
        Return the buffer containing the mask values indicating missing data and
        the buffer's associated dtype.
        Raises NoBufferPresent if null representation is not a bit or byte mask.
        r   rb   Nr   rC   shaperD   z! so does not have a separate maskzSee self.describe_null)rp   r*   r2   rD   r   rd   re   rf   r   rY   r   r   rJ   rg   r   r   r
   _maskr   rK   r   r   zerosbool_	enumerater   _NO_VALIDITY_BUFFERrk   r0   r   )r4   rn   invalidr   rD   r   maskr   validr   r   msgs               r5   r   z!PandasColumn._get_validity_buffern  s    *gdioz22 	! )/+215C^Q(8*:KLE{{}}Q't(a 3xx  F 5= dio77 	!9?(D!$''F^Q(8*:KLE5= :a=I,,, )$$&&C qLEiG83s88+RX>>>D#C.. E E3#-c3#7#7D%%WQ "$''F ^Q(8*:KLE5= 	@(.QQQCC 	@ 	@ 	@%&>???	@ c"""s   ;H H&tuple[PandasBuffer, Any]c                   | j         d         t          j        k    r| j                                        }d}t          j        t          |          dz   ft
          j                  }t          |          D ]J\  }}t          |t                    r(|                    d          }|t          |          z  }|||dz   <   Kt          |          }t          j        dt          j        t"          j        f}nt'          d          ||fS )a  
        Return the buffer containing the offset values for variable-size binary
        data (e.g., variable-length strings) and the buffer's associated dtype.
        Raises NoBufferPresent if the data buffer does not have an associated
        offsets buffer.
        r   rb   r   r   r   @   zJThis column has a fixed-length dtype so it does not have an offsets buffer)rD   r   rK   r2   r   r   r   r   int64r   r*   r   r   r   r   r   INT64r   rJ   r   )	r4   rF   ptrr   r   vr   r   rD   s	            r5   r   z PandasColumn._get_offsets_buffer  s    :a=I,,,Y''))FChc&kkAo%7rxHHHG!&)) % %1 a%% "'22A3q66MC!$A "'**F !!	EE "5  
 u}r7   )T)r"   r#   r$   r%   r&   r'   )r&   r8   )r&   r?   )r&   rv   )N)r|   r}   )r&   r   )r&   r   )r&   r   )r&   r   )__name__
__module____qualname____doc__r6   r:   propertyr>   r	   rD   rH   r`   rp   ru   ry   r{   r   r   r   r   r   r=   r7   r5   r!   r!   H   s       	 	& & & & &(       X 7 7 7 ^7:P P P PB 
 
 X
8   X& - - - ^- 1 1 1 X1       "# # # #J< < < <|7# 7# 7# 7#r& & & & & &r7   r!   )3
__future__r   typingr   r   numpyr   pandas._libs.libr   pandas._libs.tslibsr   pandas.errorsr   pandas.util._decoratorsr	   pandas.core.dtypes.dtypesr
   pandasr+   r   r   pandas.api.typesr   pandas.core.interchange.bufferr   r   *pandas.core.interchange.dataframe_protocolr   r   r   r   pandas.core.interchange.utilsr   r   r   r   r   r   r   rY   rK   r   rQ   USE_NANUSE_SENTINELrh   rI   rc   rj   r   r!   r=   r7   r5   <module>r      s   " " " " " "       
     ( ( ( ( ( ( $ $ $ $ $ $ ) ) ) ) ) ) 2 2 2 2 2 2 5 5 5 5 5 5            - , , , , ,                             BAAAAAA 
									 	 On,d34d;MN/6N^0$7N^0$7 N7<~2A6  !>:!D E E E E E6 E E E E Er7   