
    
 @gv                       d dl 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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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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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"m#Z# ddl$m%Z% erdd l&m'Z' dd!l m(Z( dd"l m)Z)  ed#e	$          Z*e%d%         Z+e#r	d&d'iZ,d(d'iZ-ni Z,i Z- ej.        dLd)d'ie, G d* d+ee*                               Z/ G d, d-ej!        e/e*                            Z0 G d. d/e0e/e*                            Z1 G d0 d1e0e/e*                            Z2 G d2 d3e1e/e*                  e2e/e*                            Z3 G d4 d5e0e/e4                            Z5 G d6 d7e0e/e4                            Z6 G d8 d9e0e/e                            Z7 G d: d;e0e/e                            Z8 G d< d=e0e/e                            Z9 G d> d?e0e/e                            Z: G d@ dAe2e/e4                            Z; G dB dCe2e/e4                            Z< G dD dEe2e/e                            Z= G dF dGe2e/e                            Z> G dH dIe2e/e                            Z? G dJ dKe2e/e                            Z@dS )M    )annotationsN)date)datetime)	timedelta)Decimal)Any)cast)Generic)Optional)overload)Tuple)Type)TYPE_CHECKING)TypeVar)Union   )ADJACENT_TO)CONTAINED_BY)CONTAINS)NOT_EXTEND_LEFT_OF)NOT_EXTEND_RIGHT_OF)OVERLAP)STRICTLY_LEFT_OF)STRICTLY_RIGHT_OF   )types)	operators)
TypeEngine)py310)Literal)ColumnElement)_TE)TypeEngineMixin_T)bound)z()[)z(]z[]slotsTkw_onlyfrozenc                  `   e Zd ZU dZdZded<   	 dZded<   	 er- ej	        d          Z
ded	<    ej	        d
          Zded<   n( ej	        d<ddieZ
ded	<    ej	        d<dd
ieZded<   es	 	 d=dd
dd>dZd?dZed?d            Zed?d            Zed?d            Zed?d            Zed?d            Zed?d            Zed@d            ZdAdZdBdZ	 dCdDd&ZdEd(ZdFd*ZdGd,ZdFd-ZdFd.ZeZ dFd/Z!e!Z"dFd0Z#dFd1Z$dHd2Z%dFd3Z&dId4Z'dId5Z(dId6Z)dId7Z*dId8Z+dId9Z,dJd:Z-dJd;Z.dS )KRangea_  Represent a PostgreSQL range.

    E.g.::

        r = Range(10, 50, bounds="()")

    The calling style is similar to that of psycopg and psycopg2, in part
    to allow easier migration from previous SQLAlchemy versions that used
    these objects directly.

    :param lower: Lower bound value, or None
    :param upper: Upper bound value, or None
    :param bounds: keyword-only, optional string value that is one of
     ``"()"``, ``"[)"``, ``"(]"``, ``"[]"``.  Defaults to ``"[)"``.
    :param empty: keyword-only, optional bool indicating this is an "empty"
     range

    .. versionadded:: 2.0

    NOptional[_T]lowerupperr&   )default_BoundsTypeboundsFboolemptyr/   )r1   r3   c               D    | j                             ||||d           d S )N)r-   r.   r1   r3   )__dict__update)selfr-   r.   r1   r3   s        Y/var/www/piapp/venv/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/ranges.py__init__zRange.__init__^   s>     M  ""$"	         returnc                    | j          S Nr3   r7   s    r8   __bool__zRange.__bool__p   s    :~r:   c                    | j         S z$A synonym for the 'empty' attribute.r>   r?   s    r8   isemptyzRange.isemptys        zr:   c                    | j         S rB   r>   r?   s    r8   is_emptyzRange.is_emptyy   rD   r:   c                $    | j         d         dk    S )z,Return True if the lower bound is inclusive.r   [r1   r?   s    r8   	lower_inczRange.lower_inc        {1~$$r:   c                $    | j          o| j        du S )zKReturn True if this range is non-empty and lower bound is
        infinite.N)r3   r-   r?   s    r8   	lower_infzRange.lower_inf       
 :~4$*"44r:   c                $    | j         d         dk    S )z,Return True if the upper bound is inclusive.r   ]rI   r?   s    r8   	upper_inczRange.upper_inc   rK   r:   c                $    | j          o| j        du S )zOReturn True if this range is non-empty and the upper bound is
        infinite.N)r3   r.   r?   s    r8   	upper_infzRange.upper_inf   rN   r:   AbstractRange[Range[_T]]c                    t                      S r=   )AbstractRanger?   s    r8   __sa_type_engine__zRange.__sa_type_engine__   s    r:   valuer$   c                z   | j         rdS | j        0| j        du p&| j        d         dk    r|| j        k     n
|| j        k    S | j        '| j        d         dk    r|| j        k    n
|| j        k    S | j        d         dk    r|| j        k    n
|| j        k    o&| j        d         dk    r|| j        k     n
|| j        k    S )z3Return True if this range contains the given value.FNr   )r   ()r3   r-   r.   r1   r7   rX   s     r8   _contains_valuezRange._contains_value   s     : 	5::% ;q>S(( 
""dj( : ;q>S(( 
""dj( {1~$$ DJ$*$
 {1~$$ DJ$*$	
r:   r   c                f   t          | j        t                    st          | j        t                    rdS t          | j        t                    st          | j        t                    rdS t          | j        t
                    st          | j        t
                    rt          d          S dS )uA   Determine the “step” for this range, if it is a discrete one.r   N)days)
isinstancer-   intr.   r   r   r   r?   s    r8   _get_discrete_stepzRange._get_discrete_step   s     dj#&& 	*TZ*E*E 	1
H-- 		J2
 2
 		
 4
D)) 	Z
D-I-I 	!$$$$4r:   value1bound1strvalue2bound2only_valuesra   c                   |dv }|dv }||cxu rn n||k    rdS |rdndS ||rdndS ||rdndS ||k    r||k    rdS |dv }|dv }	|                                  }
|
*|r
|s||
z  }d}n	|r||
z  }d}|r
|	s||
z  }d}	n	|	r||
z  }d}	||k     rdS ||k    rdS |rdS |r|	rdS |s|	s||k    rdS |rdndS |s|rdndS |	s|rdndS dS )	a  Compare two range bounds.

        Return -1, 0 or 1 respectively when `value1` is less than,
        equal to or greater than `value2`.

        When `only_value` is ``True``, do not consider the *inclusivity*
        of the edges, just their values.
        >   r[   rH   Nr   r   >   rH   rP   TF)rb   )r7   rc   rd   rf   rg   rh   value1_is_lower_boundvalue2_is_lower_bound
value1_inc
value2_incsteps              r8   _compare_edgeszRange._compare_edges   s   " !'* 4 &* 4 V########$(===q29rr9^.522A5^-51125 V& 0 01z)
z)
&&(( % '! &dNF!%J 'dNF!&J$ '! &dNF!%J 'dNF!&JF??2f__1 	1  j q 

 
(,AAA1 5=112= 19qqr9 29rr9qr:   otherc                   t          |t                    st          S | j        r	|j        rdS | j        |j        k    rdS | j        }| j        d         }|j        }|j        d         }| j        }| j        d         }|j        }|j        d         }	|                     ||||          dk    o|                     ||||	          dk    S )zCompare this range to the `other` taking into account
        bounds inclusivity, returning ``True`` if they are equal.
        TFr   r   )r`   r+   NotImplementedr3   r-   r1   r.   rp   
r7   rq   slowerslower_bolowerolower_bsuppersupper_boupperoupper_bs
             r8   __eq__zRange.__eq__(  s    
 %'' 	"!!: 	%+ 	4Z5;&&5;q><?;q><? &(CCqH M##FHfhGG1L	
r:   	Range[_T]c                B   | j         rdS |j         rdS | j        }| j        d         }|j        }|j        d         }|                     ||||          dk     rdS | j        }| j        d         }|j        }|j        d         }	|                     ||||	          dk    rdS dS )z7Determine whether this range is a contained by `other`.TFr   r   )r3   r-   r1   rp   r.   rt   s
             r8   contained_byzRange.contained_byC  s     : 	4 ; 	5;q><?vxBBQFF5;q><?vxBBQFF5tr:   Union[_T, Range[_T]]c                    t          |t                    r|                    |           S |                     |          S )z.Determine whether this range contains `value`.)r`   r+   r   r]   r\   s     r8   containszRange.contains`  s>     eU## 	/%%d+++''...r:   c                   | j         s|j         rdS | j        }| j        d         }| j        }| j        d         }|j        }|j        d         }|j        }|j        d         }	|                     ||||          dk    r|                     ||||	          dk    rdS |                     ||||          dk    r|                     ||||          dk    rdS dS )z3Determine whether this range overlaps with `other`.Fr   r   Tr3   r-   r1   r.   rp   
r7   rq   ru   rv   ry   rz   rw   rx   r{   r|   s
             r8   overlapszRange.overlapsh  s     : 	 	5;q>;q><?<? &(CCqHH##FHfhGG1LL4 &(CCqHH##FHfhGG1LL4ur:   c                    | j         s|j         rdS | j        }| j        d         }|j        }|j        d         }|                     ||||          dk     S )zBDetermine whether this range is completely to the left of `other`.Fr   r   )r3   r.   r1   r-   rp   )r7   rq   ry   rz   rw   rx   s         r8   strictly_left_ofzRange.strictly_left_of  a     : 	 	5;q><? ""68VXFFJJr:   c                    | j         s|j         rdS | j        }| j        d         }|j        }|j        d         }|                     ||||          dk    S )zCDetermine whether this range is completely to the right of `other`.Fr   r   r   )r7   rq   ru   rv   r{   r|   s         r8   strictly_right_ofzRange.strictly_right_of  r   r:   c                    | j         s|j         rdS | j        }| j        d         }|j        }|j        d         }|                     ||||          dk    S )z>Determine whether this does not extend to the left of `other`.Fr   )r3   r-   r1   rp   )r7   rq   ru   rv   rw   rx   s         r8   not_extend_left_ofzRange.not_extend_left_of  a     : 	 	5;q><? ""68VXFF!KKr:   c                    | j         s|j         rdS | j        }| j        d         }|j        }|j        d         }|                     ||||          dk    S )z?Determine whether this does not extend to the right of `other`.Fr   r   )r3   r.   r1   rp   )r7   rq   ry   rz   r{   r|   s         r8   not_extend_right_ofzRange.not_extend_right_of  r   r:   c                p   |                      ||||d          }|dk    rH|                                 }|dS |dk    r|dk    r	|||z
  k    S ||k    S |dk    r||k    S |||z
  k    S |dk    rH|dk    r|dk    s|dk    r|d	k    r|                                 }|dS |dk    r|dk    p|dk    o|d	k    S dS )
zTDetermine whether an upper bound is immediately successive to a
        lower bound.Trj   NFrP   rH   r   rZ   r[   )rp   rb   )r7   rc   rd   rf   rg   resro   s          r8   _upper_edge_adjacent_to_lowerz#Range._upper_edge_adjacent_to_lower  s    !!&&&&$GG"99**,,D|u}}S==!Vd]22!V++S==!V++!Vd]22AXX #cMMS==cMM..00#4# "cM"S= "cM	 5r:   c                "   | j         s|j         rdS | j        }| j        d         }| j        }| j        d         }|j        }|j        d         }|j        }|j        d         }	|                     ||||          p|                     ||	||          S )z8Determine whether this range is adjacent to the `other`.Fr   r   )r3   r-   r1   r.   r   r   s
             r8   adjacent_tozRange.adjacent_to  s     : 	 	5;q>;q><?<?11Hfh
 
 
//Hfh
 
	
r:   c           	        | j         r|S |j         r| S |                     |          s$|                     |          st          d          | j        }| j        d         }| j        }| j        d         }|j        }|j        d         }|j        }|j        d         }	|                     ||||          dk     r|}
|}n|}
|}|                     ||||	          dk    r|}|}n|}|	}t          |
|t          t          ||z                       S )zCompute the union of this range with the `other`.

        This raises a ``ValueError`` exception if the two ranges are
        "disjunct", that is neither adjacent nor overlapping.
        zAAdding non-overlapping and non-adjacent ranges is not implementedr   r   rI   )r3   r   r   
ValueErrorr-   r1   r.   rp   r+   r	   r0   r7   rq   ru   rv   ry   rz   rw   rx   r{   r|   rlowerrlower_brupperrupper_bs                 r8   unionzRange.union  sC    : 	L; 	K}}U## 	D,<,<U,C,C 	-  
 ;q>;q><?<?vxBBQFFFHHFHvxBBQFFFHHFHF4X5H#I#I
 
 
 	
r:   c                ,    |                      |          S r=   )r   r7   rq   s     r8   __add__zRange.__add__;  s    zz%   r:   c           	     (   | j         s|j         r| S | j        }| j        d         }| j        }| j        d         }|j        }|j        d         }|j        }|j        d         }	|                     ||||          }
|                     ||||	          }|
dk     r|dk    rt          d          |                     ||||	          }|                     ||||          }|dk    s|dk     r| S |
dk    r|dk    rt          ddd          S |
dk    rx|dk    rr|dk    rl|dk    rdnd	}|dk    r4|d	k    r.|                     ||||          dk    rt          ddd          S t          ||t          t          ||z             
          S |
dk    rx|dk    rr|dk    rl|	d	k    rdnd}|dk    r4|d	k    r.|                     ||||          dk    rt          ddd          S t          ||t          t          ||z             
          S J d|  d|             )zCompute the difference between this range and the `other`.

        This raises a ``ValueError`` exception if the two ranges are
        "disjunct", that is neither adjacent nor overlapping.
        r   r   z5Subtracting a strictly inner range is not implementedNTr>   rH   rZ   rP   rI   r[   FzUnhandled case computing z - )	r3   r-   r1   r.   rp   r   r+   r	   r0   )r7   rq   ru   rv   ry   rz   rw   rx   r{   r|   sl_vs_olsu_vs_ousl_vs_ousu_vs_olr   r   s                   r8   
differencezRange.difference>  s    : 	 	K;q>;q><?<?&&vxJJ&&vxJJa<<HqLLG   &&vxJJ&&vxJJ a<<8a<<K q==X]]t40000 q==X]]x1}}&#ooss3HCOO''&(KK  T4t4444X-@AA    q==X]]x1}}&#ooss3HCOO''&(KK  T4t4444X-@AA    	CB$BB5BBBBBr:   c                ,    |                      |          S r=   )r   r   s     r8   __sub__zRange.__sub__  s    u%%%r:   c           	        | j         s|j         s|                     |          st          ddd          S | j        }| j        d         }| j        }| j        d         }|j        }|j        d         }|j        }|j        d         }	|                     ||||          dk     r|}
|}n|}
|}|                     ||||	          dk    r|}|	}n|}|}t          |
|t          t          ||z                       S )zdCompute the intersection of this range with the `other`.

        .. versionadded:: 2.0.10

        NTr>   r   r   rI   )	r3   r   r+   r-   r1   r.   rp   r	   r0   r   s                 r8   intersectionzRange.intersection  s     : 	1 	1DMM%,@,@ 	1t40000;q>;q><?<?vxBBQFFFHHFHvxBBQFFFHHFHX%899
 
 
 	
r:   c                ,    |                      |          S r=   )r   r   s     r8   __mul__zRange.__mul__  s      '''r:   c                *    |                                  S r=   )
_stringifyr?   s    r8   __str__zRange.__str__  s       r:   c                    | j         rdS | j        | j        }}|dn|}|dn|}t          d| j                  \  }}| | d| | S )Nr3    zTuple[str, str],)r3   r-   r.   r	   r1   )r7   lrb0b1s        r8   r   zRange._stringify  sl    : 	7z4:1)BB)BB'55B!a!!!!R!!!r:    )NN)r-   r,   r.   r,   r1   r0   r3   r2   )r;   r2   )r;   rT   )rX   r$   r;   r2   )r;   r   )F)rc   r,   rd   re   rf   r,   rg   re   rh   r2   r;   ra   )rq   r   r;   r2   )rq   r~   r;   r2   )rX   r   r;   r2   )
rc   r,   rd   re   rf   r,   rg   re   r;   r2   )rq   r~   r;   r~   )r;   re   )/__name__
__module____qualname____doc__r-   __annotations__r.   r   dataclassesfieldr1   r3   	dc_kwonlyr   r9   r@   propertyrC   rF   rJ   rM   rQ   rS   rW   r]   rb   rp   r}   r   r   r   r   
__lshift__r   
__rshift__r   r   r   r   r   r   r   r   r   r   r   r   r   r:   r8   r+   r+   8   s         * EE D/k/======='k'66666666/k/JJJ	JJJJJJ'k'CCCCCCCCC  #'"&	
 #'	 	 	 	 	 	$       X
    X
 % % % X%
 5 5 5 X5 % % % X%
 5 5 5 X5    X
 
 
 
<   4 "W W W W Wr
 
 
 
6   :/ / / /   @K K K K "JK K K K #JL L L LL L L L- - - -^
 
 
 
,,
 ,
 ,
 ,
\! ! ! !JC JC JC JCX& & & &$
 $
 $
 $
L( ( ( (! ! ! !
" 
" 
" 
" 
" 
"r:   r+   c                       e Zd ZdZdZdZedd	            Zedd            Zd fdZddZ G d de	j
        ee                            Z xZS )rV   z
    Base for PostgreSQL RANGE types.

    .. seealso::

        `PostgreSQL range functions <https://www.postgresql.org/docs/current/static/functions-range.html>`_

    Tcls	Type[_TE]kwr   r;   r"   c                    d S r=   r   r7   r   r   s      r8   adaptzAbstractRange.adapt      r:   Type[TypeEngineMixin]TypeEngine[Any]c                    d S r=   r   r   s      r8   r   zAbstractRange.adapt  r   r:   -Type[Union[TypeEngine[Any], TypeEngineMixin]]c                    t          |t                    r5|| j        ur,| j        } t	          | d|| j        fd|i                      S t                                          |          S )a	  Dynamically adapt a range type to an abstract impl.

        For example ``INT4RANGE().adapt(_Psycopg2NumericRange)`` should
        produce a type that will have ``_Psycopg2NumericRange`` behaviors
        and also render as ``INT4RANGE`` in SQL and DDL.

        	RangeImpl__visit_name__)
issubclassAbstractRangeImpl	__class__r   typesuperr   )r7   r   r   
visit_namer   s       r8   r   zAbstractRange.adapt  s     c,-- 	&#T^2K2K ,J4(((dn%!:.     77==%%%r:   rX   c                   |j         |j         n|j        }t          |t                    rt	                      S t          |t
          t          f          rt                      S t          |t                    r#|j	        st                      nt                      S t          |t                    rt                      S t          j        S r=   )r-   r.   r`   ra   	INT8RANGEr   floatNUMRANGEr   tzinfoTSRANGE	TSTZRANGEr   	DATERANGEsqltypesNULLTYPE)r7   rX   specs      r8   _resolve_for_literalz"AbstractRange._resolve_for_literal  s    #k5u{{5;dC   
	%;;w.// 	%::h'' 	%$(K@7999Y[[@d## 	%;; $$r:   c                  r    e Zd ZdZddZddZdd	Zdd
ZeZddZ	e	Z
ddZddZddZddZddZddZdS ) AbstractRange.comparator_factoryz-Define comparison operations for range types.rq   r   r   r;   ColumnElement[bool]c                B    | j                             t          |          S )a
  Boolean expression. Returns true if the right hand operand,
            which can be an element or a range, is contained within the
            column.

            kwargs may be ignored by this operator but are required for API
            conformance.
            )exproperater   )r7   rq   r   s      r8   r   z)AbstractRange.comparator_factory.contains  s     9$$Xu555r:   c                B    | j                             t          |          S )zsBoolean expression. Returns true if the column is contained
            within the right hand operand.
            )r   r   r   r   s     r8   r   z-AbstractRange.comparator_factory.contained_by  s     9$$\5999r:   c                B    | j                             t          |          S )zBoolean expression. Returns true if the column overlaps
            (has points in common with) the right hand operand.
            )r   r   r   r   s     r8   r   z)AbstractRange.comparator_factory.overlaps  s     9$$We444r:   c                B    | j                             t          |          S )zsBoolean expression. Returns true if the column is strictly
            left of the right hand operand.
            )r   r   r   r   s     r8   r   z1AbstractRange.comparator_factory.strictly_left_of#  s     9$$%5u===r:   c                B    | j                             t          |          S )ztBoolean expression. Returns true if the column is strictly
            right of the right hand operand.
            )r   r   r   r   s     r8   r   z2AbstractRange.comparator_factory.strictly_right_of+  s     9$$%6>>>r:   c                B    | j                             t          |          S )zBoolean expression. Returns true if the range in the column
            does not extend right of the range in the operand.
            )r   r   r   r   s     r8   r   z4AbstractRange.comparator_factory.not_extend_right_of3  s     9$$%8%@@@r:   c                B    | j                             t          |          S )zBoolean expression. Returns true if the range in the column
            does not extend left of the range in the operand.
            )r   r   r   r   s     r8   r   z3AbstractRange.comparator_factory.not_extend_left_of9  s     9$$%7???r:   c                B    | j                             t          |          S )z}Boolean expression. Returns true if the range in the column
            is adjacent to the range in the operand.
            )r   r   r   r   s     r8   r   z,AbstractRange.comparator_factory.adjacent_to?  s     9$$[%888r:   c                L    | j                             t          j        |          S zRange expression. Returns the union of the two ranges.
            Will raise an exception if the resulting range is not
            contiguous.
            )r   r   r   addr   s     r8   r   z&AbstractRange.comparator_factory.unionE      
 9$$Y]E:::r:   c                L    | j                             t          j        |          S r   )r   r   r   subr   s     r8   r   z+AbstractRange.comparator_factory.differenceL  r   r:   ColumnElement[Range[_T]]c                L    | j                             t          j        |          S )zRange expression. Returns the intersection of the two ranges.
            Will raise an exception if the resulting range is not
            contiguous.
            )r   r   r   mulr   s     r8   r   z-AbstractRange.comparator_factory.intersectionS  r   r:   N)rq   r   r   r   r;   r   )rq   r   r;   r   )rq   r   r;   r   )r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r:   r8   comparator_factoryr   
  s       ;;	6 	6 	6 	6	: 	: 	: 	:	5 	5 	5 	5	> 	> 	> 	> &
	? 	? 	? 	? '
	A 	A 	A 	A	@ 	@ 	@ 	@	9 	9 	9 	9	; 	; 	; 	;	; 	; 	; 	;	; 	; 	; 	; 	; 	;r:   r   )r   r   r   r   r;   r"   )r   r   r   r   r;   r   )r   r   r   r   r;   r   )rX   r   r;   r   )r   r   r   r   render_bind_cast__abstract__r   r   r   r   
Comparatorr+   r   r   __classcell__)r   s   @r8   rV   rV     s          L   X    X& & & & & &>% % % %N; N; N; N; N;Z25:> N; N; N; N; N; N; N;r:   rV   c                      e Zd ZdZdS )r   KMarker for AbstractRange that will apply a subclass-specific
    adaptationNr   r   r   r   r   r:   r8   r   r   [  s           r:   r   c                      e Zd ZdZdZdS )AbstractMultiRangez$base for PostgreSQL MULTIRANGE typesTN)r   r   r   r   r   r   r:   r8   r  r  `  s        ..LLLr:   r  c                      e Zd ZdZdS )AbstractMultiRangeImplr  Nr  r   r:   r8   r  r  f  s           r:   r  c                      e Zd ZdZd ZdS )	INT4RANGEz(Represent the PostgreSQL INT4RANGE type.Nr   r   r   r   r   r   r:   r8   r  r  m          22 NNNr:   r  c                      e Zd ZdZd ZdS )r   z(Represent the PostgreSQL INT8RANGE type.Nr	  r   r:   r8   r   r   s  r
  r:   r   c                      e Zd ZdZd ZdS )r   z'Represent the PostgreSQL NUMRANGE type.Nr	  r   r:   r8   r   r   y  s        11NNNr:   r   c                      e Zd ZdZd ZdS )r   z(Represent the PostgreSQL DATERANGE type.Nr	  r   r:   r8   r   r     r
  r:   r   c                      e Zd ZdZd ZdS )r   &Represent the PostgreSQL TSRANGE type.Nr	  r   r:   r8   r   r     s        00NNNr:   r   c                      e Zd ZdZd ZdS )r   (Represent the PostgreSQL TSTZRANGE type.Nr	  r   r:   r8   r   r     r
  r:   r   c                      e Zd ZdZd ZdS )INT4MULTIRANGEz-Represent the PostgreSQL INT4MULTIRANGE type.Nr	  r   r:   r8   r  r            77%NNNr:   r  c                      e Zd ZdZd ZdS )INT8MULTIRANGEz-Represent the PostgreSQL INT8MULTIRANGE type.Nr	  r   r:   r8   r  r    r  r:   r  c                      e Zd ZdZd ZdS )NUMMULTIRANGEz,Represent the PostgreSQL NUMMULTIRANGE type.Nr	  r   r:   r8   r  r    s        66$NNNr:   r  c                      e Zd ZdZd ZdS )DATEMULTIRANGEz-Represent the PostgreSQL DATEMULTIRANGE type.Nr	  r   r:   r8   r  r    r  r:   r  c                      e Zd ZdZd ZdS )TSMULTIRANGEr  Nr	  r   r:   r8   r  r    s        00#NNNr:   r  c                      e Zd ZdZd ZdS )TSTZMULTIRANGEr  Nr	  r   r:   r8   r  r    s        22%NNNr:   r  r   )A
__future__r   r   r   r   r   decimalr   typingr   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   sqlsql.type_apir   utilr   util.typingr    sql.elementsr!   r"   r#   r$   r0   dc_slotsr   	dataclassr+   rV   r   r  r  ra   r  r   r   r   r   r   r  r  r  r  r  r  r   r:   r8   <module>r)     sD   # " " " " "                                                                                               " " " " " " # # # # # #       ) ) ) ) ) ) * * * * * *       ' ' ' ' ' ' ( ( ( ( ( ( ! ! ! ! ! !       & & & & & &       " " " " " " 0------######//////WT,- HD!IIHI //d/h//J
" J
" J
" J
" J
"GBK J
" J
" 0/J
"ZR; R; R; R; R;H'b	2 R; R; R;j    eBi0   
    uRy1       eBi "4U2Y"?  ! ! ! ! !eCj) ! ! !! ! ! ! !eCj) ! ! !         }U7^,      ! ! ! ! !eDk* ! ! !    mE(O,   ! ! ! ! !eHo. ! ! !& & & & &'c
3 & & && & & & &'c
3 & & &% % % % %&uW~6 % % %& & & & &'d4 & & &$ $ $ $ $%eHo6 $ $ $& & & & &'h8 & & & & &r:   