
    ˀh6                    v    d dl mZ d dlmZmZ d dlmZ erd dlm	Z	m
Z
mZ ed   Z G d d      Z G d d	      Zy)
    )annotations)TYPE_CHECKINGUnionN)	DataFrame	LazyFrameSeries)r   r   c                      e Zd ZU dZded<   ded<   ded<   ded<   ded<   d	ed
<   ddZedd       Zedd       ZddZ	ddZ
ddZddZy)PolarsSlicez}
    Apply Python slice object to Polars DataFrame or Series.

    Has full support for negative indexing and/or stride.
    intstopstartstrideslice_lengthboolis_unboundedFrameOrSeriesobjc                    || _         y Nr   selfr   s     o/var/www/html/wine-match-dev/backend/winematch-backend/venv/lib/python3.12/site-packages/polars/_utils/slice.py__init__zPolarsSlice.__init__   	        c                z    | j                         }t        |t        j                        r|S |j	                         S )z.Return lazy variant back to its original type.)collect
isinstanceplr   	to_series)lazyoriginalframes      r   _as_originalzPolarsSlice._as_original   s.     "8R\\:uQ@QQr   c                    t        | t        j                        r| j                         j	                         S | j	                         S )z2Make lazy to ensure efficient/consistent handling.)r   r    r   to_framer"   r   s    r   _lazifyzPolarsSlice._lazify$   s1     )33		(Bs||~""$R
Rr   c                    |j                  | j                  | j                        j                  | j                        S )z&Logic for slices with positive stride.)slicer   r   gather_everyr   r   s     r   _slice_positivezPolarsSlice._slice_positive)   s.     yyT%6%67DDT[[QQr   c                    t        | j                        }|j                  | j                  dz   | j                        j                         }|dkD  r|j                  |      S |S )z&Logic for slices with negative stride.   )absr   r*   r   r   reverser+   )r   r   r   	lazyslices       r   _slice_negativezPolarsSlice._slice_negative.   sS    T[[!IIdii!mT->->?GGI	281*y%%f-L9Lr   c                   t        | j                        }t        |j                  |j                  |j
                        j                  |      \  }}}|dk\  r|dk  xr ||k\  | _        n|dk(  xr ||dz
  k\  | _        | j                  j                         rd| _	        nB| j                  r|| _	        n.||k(  s|dkD  r||kD  s
|dk  r||k  rdnt        ||z
        | _	        |||c| _        | _        | _        y)zENormalise slice bounds, identify unbounded and/or zero-length slices.r.   r   N)lenr   r*   r   r   stepindicesr   is_emptyr   r/   r   )r   sobj_lenr   r   r   s         r   _slice_setupzPolarsSlice._slice_setup4   s     dhh-#AGGQVVQVV<DDWMtV Q;!&! B$'/D!% G%7Q;2FD 88 !D 'D
 d]
ut|
ut|	  &  .3D&*
DIt{r   c                H   | j                  |       | j                  dk(  r| j                  j                         S | j                  rQ| j
                  dv rC| j
                  dk  r| j                  j                         S | j                  j                         S | j                  dk\  rN| j                  dk\  r?| j
                  dk(  r0| j                  j                  | j                  | j                        S | j
                  dk  r8| j                  dk(  r)| j                  j                  | j                  dz   d      S | j                  | j                        }| j
                  dkD  r| j                  |      n| j                  |      }| j                  || j                        S )zFApply a slice operation, taking advantage of any potential fast paths.r   )r4   r.   r.   )r;   r   r   clearr   r   r0   cloner   r   r*   r(   r,   r2   r%   )r   r9   lazyobjsliceds       r   applyzPolarsSlice.applyQ   sE    	! !88>>##4;;'#9*.++/488##%P@PPZZ1_aDKK14D88>>$**d.?.?@@[[1_!2!2a!788>>$))a-33 ll488,G ;;? $$W-))'2 
 $$VTXX66r   N)r   r   returnNone)r"   r   r#   r   rB   r   )r   r   rB   r   )r   r   rB   r   )r9   r*   rB   rC   )r9   r*   rB   r   )__name__
__module____qualname____doc____annotations__r   staticmethodr%   r(   r,   r2   r;   rA    r   r   r
   r
      sr     IJK	 R R
 S SR
MA:7r   r
   c                  ,    e Zd ZU dZded<   ddZddZy)	LazyPolarsSlicez
    Apply python slice object to Polars LazyFrame.

    Only slices with efficient computation paths that map directly
    to existing lazy methods are supported.
    r   r   c                    || _         y r   r   r   s     r   r   zLazyPolarsSlice.__init__w   r   r   c                   |j                   xs d}|j                  xs d}|j                  r|j                  dk  rd}t        |      |dk  rG|dkD  s|j                  6||j                  k7  r'|dcxkD  r|kD  rn n|j                  d}t        |      |dkD  r|j                  ||j                  k\  s?|dk  rT|j                   H|j                  <|j                  |j                   cxk\  rdk\  rn n| j                  j                         S |j                   |j                  |dk(  r| j                  j                         S |dkD  r| j                  j                  |      S |dk(  r| j                  j                         S |dk  r| j                  j                         j                  t        |            S |dcxk\  r|kD  ron nl|j                  `| j                  j                  |j                   dz         j                         }t        |      dk(  r|S |j                  t        |            S |dk(  rP|j                  xs ddk\  r=| j                  j                  |j                        }|dk(  r|S |j                  |      S |dk  rM|j                  A|dkD  r<| j                  j                  t        |            }|dk(  r|S |j                  |      S |dkD  rl|j                  |j                  dk\  rQ|j                  dn|j                  |z
  }| j                  j                  ||      }|dk(  r|S |j                  |      S d|d}t        |      )	a  
        Apply a slice operation.

        Note that LazyFrame is designed primarily for efficient computation and does not
        know its own length so, unlike DataFrame, certain slice patterns (such as those
        requiring negative stop/step) may not be supported.
        r   r.   z.negative stop is not supported for lazy slicesNz?negative stride is not supported in conjunction with start+stopr4   zthe given slice zv is not supported by lazy computation

Consider a more efficient approach, or construct explicitly with other methods.)r   r6   r   
ValueErrorr   r=   r>   r+   r0   r/   headtailr*   )r   r9   r   r6   msgr   r   s          r   rA   zLazyPolarsSlice.applyz   s    1vv{ 66affqjBCS/!!8aff&8uA$$W o% 1H!&&,!&&1H$);!''@VUV@V88>>## WW_qyxx~~''xx,,T22xx''))xx'')66s4yAA a$166>((--!,446Ct9>3K0@0@T0KK aZQVV[qQ.((--'C193A3+;+;D+AA QY166>dQh((--E
+C193A3+;+;D+AA QYAFFNaffk$%FFN4!&&5.L((..5C193A3+;+;D+AA qe $b b 	 or   N)r   r   rB   rC   )r9   r*   rB   r   )rD   rE   rF   rG   rH   r   rA   rJ   r   r   rL   rL   m   s     
N]r   rL   )
__future__r   typingr   r   polars._reexport	_reexportr    polarsr   r   r   r   r
   rL   rJ   r   r   <module>rX      s;    " ' 33/0M]7 ]7@j jr   