[hҀRddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZ ddl!mZddl"m#Z#dd l$m%Z%dd!l&m'Z'erdd"l(m)Z)dd#l"m*Z*dd$l"m+Z+ed%e &Z,e'd'Z-e%r d(d)iZ.d*d)iZ/niZ.iZ/ej0dYd+d)ie.Gd,d-e e,Z1Gd.d/e e1e,Z2Gd0d1e j#e,Z3Gd2d3e3e1e,Z4Gd4d5e4e,Z5Gd6d7e3ee1e,Z6Gd8d9e6e,Z7Gd:d;e4e8Z9Gd<d=e4e8Z:Gd>d?e4eZ;Gd@dAe4eZ<GdBdCe4eZ=GdDdEe4eZ>GdFdGe6e8Z?GdHdIe6e8Z@GdJdKe6eZAGdLdMe6eZBGdNdOe6eZCGdPdQe6eZDdRZEdSZFdZdXZGdS)[) annotationsN)date)datetime) timedelta)Decimal)Any)cast)Generic)List)Optional)overload)Sequence)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[]slotsTkw_onlyfrozencdeZdZUdZdZded< dZded< er-ej dZ ded <ej d Z d ed <n(ej ddZd?dZed?dZed?dZed?dZed?dZed?dZed?dZed@dZdAdZdBdZ dCdDd&ZdEd(ZdFd*ZdGd,ZeZdFd-ZdFd.Z e Z!dFd/Z"e"Z#dFd0Z$dFd1Z%dHd2Z&dFd3Z'dId4Z(dId5Z)dId6Z*dId7Z+dId8Z,dId9Z-dJd:Z.dJd;Z/dS)KRangea_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]lowerupperr()default _BoundsTypeboundsFboolemptyr1)r3r5cD|j||||ddS)N)r/r0r3r5)__dict__update)selfr/r0r3r5s t/var/www/api.easyaligner.net/htdocs/venv_linux/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/ranges.py__init__zRange.__init__as> M ""$"      returnc|j SNr5r9s r:__bool__zRange.__bool__ss :~r<c|jSz$A synonym for the 'empty' attribute.r@rAs r:isemptyz Range.isemptyv zr<c|jSrDr@rAs r:is_emptyzRange.is_empty|rFr<c$|jddkS)z,Return True if the lower bound is inclusive.r[r3rAs r: lower_inczRange.lower_inc{1~$$r<c$|j o|jduS)zKReturn True if this range is non-empty and lower bound is infinite.N)r5r/rAs r: lower_infzRange.lower_inf :~4$*"44r<c$|jddkS)z,Return True if the upper bound is inclusive.r]rKrAs r: upper_inczRange.upper_incrMr<c$|j o|jduS)zOReturn True if this range is non-empty and the upper bound is infinite.N)r5r0rAs r: upper_infzRange.upper_infrPr<AbstractSingleRange[_T]ctSr?)AbstractSingleRangerAs r:__sa_type_engine__zRange.__sa_type_engine__s"$$$r<valuer&cz|jrdS|j0|jdup&|jddkr ||jkn ||jkS|j'|jddkr ||jkn ||jkS|jddkr ||jkn ||jko&|jddkr ||jkn ||jkS)z3Return True if this range contains the given value.FNr)r()r5r/r0r3r9rZs r:_contains_valuezRange._contains_values : 5 : :%;q>S(( ""dj(  : ;q>S(( ""dj( {1~$$ DJ  $*$ {1~$$ DJ  $*$ r<rcft|jtst|jtrdSt|jtst|jtrdSt|jt st|jt rt dSdS)uADetermine the “step” for this range, if it is a discrete one.rN)days) isinstancer/intr0rrrrAs r:_get_discrete_stepzRange._get_discrete_steps dj# & & *TZ*E*E 1  H - -  J2 2  4  D ) ) Z D-I-I !$$$ $4r<value1bound1strvalue2bound2 only_valuesrcc|dv}|dv}||cxurnn||krdS|rdndS||rdndS||rdndS||kr||krdS|dv}|dv} |} | *|r |s|| z }d}n |r|| z }d}|r | s|| z }d} n | r|| z }d} ||krdS||krdS|rdS|r| rdS|s| s||krdS|rdndS|s|rdndS| s|rdndSdS) aCompare 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]rJNrr>rJrRTF)rd) r9rerfrhrirjvalue1_is_lower_boundvalue2_is_lower_bound value1_inc value2_incsteps r:_compare_edgeszRange._compare_edgess"!'* 4 &* 4 V # # # # # # # #$(===q29rr9 ^.522A 5 ^-5112 5 V  & 0 01z) z) &&((  % '!&dNF!%J'dNF!&J$ '!&dNF!%J'dNF!&J F??2 f__1  1  j q  (,AAA1 5=112= 19qqr9 29rr9qr<otherct|tstS|jr |jrdS|j|jkrdS|j}|jd}|j}|jd}|j}|jd}|j}|jd} |||||dko||||| dkS)zCompare this range to the `other` taking into account bounds inclusivity, returning ``True`` if they are equal. TFrr)rbr-NotImplementedr5r/r3r0rr r9rsslowerslower_bolowerolower_bsuppersupper_boupperoupper_bs r:__eq__z Range.__eq__+s %'' "! ! : %+ 4 Z5; & &5;q><?;q><?   &( C Cq H M##FHfhGG1L r< Range[_T]cB|jrdS|jrdS|j}|jd}|j}|jd}|||||dkrdS|j}|jd}|j}|jd} ||||| dkrdSdS)z7Determine whether this range is a contained by `other`.TFrr)r5r/r3rrr0rvs r: contained_byzRange.contained_byFs : 4 ; 5;q><?   vx B BQ F F5;q><?   vx B BQ F F5tr<Union[_T, Range[_T]]ct|tr||S||S)z.Determine whether this range contains `value`.)rbr-rr_r^s r:containszRange.containscs> eU # # /%%d++ +''.. .r<c|js|jrdS|j}|jd}|j}|jd}|j}|jd}|j}|jd} |||||dkr||||| dkrdS|||||dkr|||||dkrdSdS)z3Determine whether this range overlaps with `other`.FrrTr5r/r3r0rr r9rsrwrxr{r|ryrzr}r~s r:overlapszRange.overlapsms :  5;q>;q><?<?   &( C Cq H H##FHfhGG1LL4   &( C Cq H H##FHfhGG1LL4ur<c|js|jrdS|j}|jd}|j}|jd}|||||dkS)zBDetermine whether this range is completely to the left of `other`.Frr)r5r0r3r/rr)r9rsr{r|ryrzs r:strictly_left_ofzRange.strictly_left_ofa :  5;q><?""68VXFFJJr<c|js|jrdS|j}|jd}|j}|jd}|||||dkS)zCDetermine whether this range is completely to the right of `other`.Frrr)r9rsrwrxr}r~s r:strictly_right_ofzRange.strictly_right_ofrr<c|js|jrdS|j}|jd}|j}|jd}|||||dkS)z>Determine whether this does not extend to the left of `other`.Fr)r5r/r3rr)r9rsrwrxryrzs r:not_extend_left_ofzRange.not_extend_left_ofa :  5;q><?""68VXFF!KKr<c|js|jrdS|j}|jd}|j}|jd}|||||dkS)z?Determine whether this does not extend to the right of `other`.Frr)r5r0r3rr)r9rsr{r|r}r~s r:not_extend_right_ofzRange.not_extend_right_ofrr<cp|||||d}|dkrH|}|dS|dkr|dkr |||z kS||kS|dkr||kS|||z kS|dkrH|dkr|dks |dkr|d kr|}|dS|dkr|dkp |dko|d kSdS) zTDetermine whether an upper bound is immediately successive to a lower bound.TrlNFrRrJrr\r])rrrd)r9rerfrhriresrqs r:_upper_edge_adjacent_to_lowerz#Range._upper_edge_adjacent_to_lowers!!&&&&$GG "99**,,D|u}}S==!Vd]22!V++S==!V++!Vd]22 AXX# cMMS==cMM..00#4# "cM"S="cM  5r<c"|js|jrdS|j}|jd}|j}|jd}|j}|jd}|j}|jd} |||||p||| ||S)z8Determine whether this range is adjacent to the `other`.Frr)r5r/r3r0rrs r: adjacent_tozRange.adjacent_tos :  5;q>;q><?<?11 Hfh    / / Hfh   r<c |jr|S|jr|S||s$||std|j}|jd}|j}|jd}|j}|jd}|j}|jd} |||||dkr|} |} n|} |} ||||| dkr|} |} n|} | } t| | tt| | zS)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 implementedrrrK) r5rr ValueErrorr/r3r0rrr-r r2r9rsrwrxr{r|ryrzr}r~rlowerrlower_brupperrupper_bs r:unionz Range.unionsC : L ; K}}U## D,<,;q><?<?   vx B BQ F FFHHFH   vx B BQ F FFHHFH F4 X5H#I#I    r<c,||Sr?)rr9rss r:__add__z Range.__add__@szz%   r<c (|js|jr|S|j}|jd}|j}|jd}|j}|jd}|j}|jd} |||||} ||||| } | dkr| dkrt d||||| } |||||} | dks| dkr|S| dkr| dkrt dddS| dkrx| dkrr| dkrl|dkrdnd }|dkr4|d kr.|||||dkrt dddSt ||tt||z S| dkrx| dkrr| dkrl| d krd nd}|dkr4|d kr.|||||dkrt dddSt ||tt||z SJd |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. rrz5Subtracting a strictly inner range is not implementedNTr@rJr\rRrKr]FzUnhandled case computing z - ) r5r/r3r0rrrr-r r2)r9rsrwrxr{r|ryrzr}r~sl_vs_olsu_vs_ousl_vs_ousu_vs_olrrs r: differencezRange.differenceCs :  K;q>;q><?<?&&vxJJ&&vxJJ a<;q><?<?   vx B BQ F FFHHFH   vx B BQ F FFHHFH   X%899    r<c,||Sr?)rrs r:__mul__z Range.__mul__s  '''r<c*|Sr?) _stringifyrAs r:__str__z Range.__str__s   r<c|jrdS|j|j}}|dn|}|dn|}td|j\}}||d||S)Nr5zTuple[str, str],)r5r/r0r r3)r9lrb0b1s r:rzRange._stringifysl : 7z4:1)BB)BB'55B!a!!!!R!!!r<)NN)r/r.r0r.r3r2r5r4)r=r4)r=rV)rZr&r=r4)r=r)F) rer.rfrgrhr.rirgrjr4r=rc)rsrr=r4)rsrr=r4)rZrr=r4) rer.rfrgrhr.rirgr=r4)rsrr=r)r=rg)0__name__ __module__ __qualname____doc__r/__annotations__r0r dataclassesfieldr3r5 dc_kwonlyr!r;rBpropertyrErHrLrOrSrUrYr_rdrrrrr __contains__rr __lshift__r __rshift__rrrrrrrrrrrrrr<r:r-r-;s*EED/k/======='k'66666666/k/JJJ JJJJJJ'k'CCCCCCCCC #'"&  #'       $X X %%%X% 555X5 %%%X% 555X5 %%%X%    <4" WWWWWr    6:////L@ K K K K"J K K K K#J L L L L L L L L----^    ,, , , , \!!!!JCJCJCJCX&&&&$ $ $ $ L((((!!!! " " " " " "r<r-c*eZdZdZeddZdS) MultiRangea?Represents a multirange sequence. This list subclass is an utility to allow automatic type inference of the proper multi-range SQL type depending on the single range values. This is useful when operating on literal multi-ranges:: import sqlalchemy as sa from sqlalchemy.dialects.postgresql import MultiRange, Range value = literal(MultiRange([Range(2, 4)])) select(tbl).where(tbl.c.value.op("@")(MultiRange([Range(-3, 7)]))) .. versionadded:: 2.0.26 .. seealso:: - :ref:`postgresql_multirange_list_use`. r=AbstractMultiRange[_T]ctSr?)AbstractMultiRangerAs r:rYzMultiRange.__sa_type_engine__s!###r<N)r=r)rrrrrrYrr<r:rrs>($$$X$$$r<rceZdZdZdZdZedd Zedd Zdfd ZGddej e e Z xZ S) AbstractRangez0Base class for single and multi Range SQL types.Tcls Type[_TE]kwrr=r$c dSr?rr9rrs r:adaptzAbstractRange.adapts7:sr<Type[TypeEngineMixin]TypeEngine[Any]c dSr?rrs r:rzAbstractRange.adapts #r<-Type[Union[TypeEngine[Any], TypeEngineMixin]]c t|ttfr5||jur,|j}t |d||jfd|iSt |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__) issubclassAbstractSingleRangeImplAbstractMultiRangeImpl __class__rtypesuperr)r9rr visit_namers r:rzAbstractRange.adapts s46LM N N &4>)),J4(((dn%!:.  77==%% %r<creZdZdZddZddZdd Zdd ZeZdd Z e Z dd Z dd Z ddZ ddZddZddZdS) AbstractRange.comparator_factoryz-Define comparison operations for range types.rsrrr=ColumnElement[bool]c B|jt|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. )exproperater)r9rsrs r:rz)AbstractRange.comparator_factory.containss9$$Xu55 5r<cB|jt|S)zsBoolean expression. Returns true if the column is contained within the right hand operand. )rrrrs r:rz-AbstractRange.comparator_factory.contained_by#s9$$\599 9r<cB|jt|S)zBoolean expression. Returns true if the column overlaps (has points in common with) the right hand operand. )rrrrs r:rz)AbstractRange.comparator_factory.overlaps)s9$$We44 4r<cB|jt|S)zsBoolean expression. Returns true if the column is strictly left of the right hand operand. )rrrrs r:rz1AbstractRange.comparator_factory.strictly_left_of/s9$$%5u== =r<cB|jt|S)ztBoolean expression. Returns true if the column is strictly right of the right hand operand. )rrrrs r:rz2AbstractRange.comparator_factory.strictly_right_of7s9$$%6>> >r<cB|jt|S)zBoolean expression. Returns true if the range in the column does not extend right of the range in the operand. )rrrrs r:rz4AbstractRange.comparator_factory.not_extend_right_of?s9$$%8%@@ @r<cB|jt|S)zBoolean expression. Returns true if the range in the column does not extend left of the range in the operand. )rrrrs r:rz3AbstractRange.comparator_factory.not_extend_left_ofEs9$$%7?? ?r<cB|jt|S)z}Boolean expression. Returns true if the range in the column is adjacent to the range in the operand. )rrrrs r:rz,AbstractRange.comparator_factory.adjacent_toKs9$$[%88 8r<cL|jtj|SzRange expression. Returns the union of the two ranges. Will raise an exception if the resulting range is not contiguous. )rrraddrs r:rz&AbstractRange.comparator_factory.unionQ 9$$Y]E:: :r<cL|jtj|Sr)rrrsubrs r:rz+AbstractRange.comparator_factory.differenceXrr<ColumnElement[Range[_T]]cL|jtj|S)zRange expression. Returns the intersection of the two ranges. Will raise an exception if the resulting range is not contiguous. )rrrmulrs r:rz-AbstractRange.comparator_factory.intersection_rr<N)rsrrrr=r)rsrr=r)rsrr=r)rrrrrrrrrrrrrrrrrrr<r:comparator_factoryrs ;; 6 6 6 6 : : : :  5 5 5 5  > > > > &  ? ? ? ? '  A A A A  @ @ @ @  9 9 9 9  ; ; ; ; ; ; ; ; ; ; ; ; ; ;r<r)rrrrr=r$)rrrrr=r)rrrrr=r)rrrrrender_bind_cast __abstract__r rr Comparatorr-rr __classcell__)rs@r:rrs::L :::X: X & & & & & &DN;N;N;N;N;Z25:>N;N;N;N;N;N;N;r<rceZdZdZdZd dZdS) rXzBase for PostgreSQL RANGE types. These are types that return a single :class:`_postgresql.Range` object. .. seealso:: `PostgreSQL range functions `_ TrZ Range[Any]r=rc|j|jn|j}t|tr+t |rt St St|ttfrtSt|tr#|j stn tSt|trtSt jSr?)r/r0rbrc _is_int32 INT4RANGE INT8RANGErfloatNUMRANGErtzinfoTSRANGE TSTZRANGEr DATERANGEsqltypesNULLTYPE)r9rZspecs r:_resolve_for_literalz(AbstractSingleRange._resolve_for_literalts#k5u{{5; dC  % # {{" {{" w. / / %::  h ' ' %$(K@7999Y[[ @ d # # %;; $ $r<N)rZrr=rrrrrrr rr<r:rXrXgs9L%%%%%%r<rXceZdZdZdS)rzQMarker for AbstractSingleRange that will apply a subclass-specific adaptationNrrrrrr<r:rrr<rceZdZdZdZd dZdS) rzBase for PostgreSQL MULTIRANGE types. these are types that return a sequence of :class:`_postgresql.Range` objects. TrZSequence[Range[Any]]r=rc|s tjS|d}|j|jn|j}t |t r5t d|DrtStSt |ttfrtSt |tr#|j stn tSt |t rt#StjS)Nrc34K|]}t|VdSr?)r).0rs r: z:AbstractMultiRange._resolve_for_literal..s(//A9Q<<//////r<)r r r/r0rbrcallINT4MULTIRANGEINT8MULTIRANGErr NUMMULTIRANGErr TSMULTIRANGETSTZMULTIRANGErDATEMULTIRANGE)r9rZfirstr s r:r z'AbstractMultiRange._resolve_for_literals %$ $a#k5u{{5; dC  %/////// (%'''%''' w. / / % ?? " h ' ' %)-J<>>>.:J:J J d # # %!## #$ $r<N)rZrr=rr rr<r:rrs9L%%%%%%r<rceZdZdZdS)rzPMarker for AbstractMultiRange that will apply a subclass-specific adaptationNrrr<r:rrrr<rceZdZdZdZdS)rz(Represent the PostgreSQL INT4RANGE type.Nrrrrrrr<r:rr22 NNNr<rceZdZdZdZdS)rz(Represent the PostgreSQL INT8RANGE type.Nr!rr<r:rrr"r<rceZdZdZdZdS)rz'Represent the PostgreSQL NUMRANGE type.Nr!rr<r:rrs11NNNr<rceZdZdZdZdS)rz(Represent the PostgreSQL DATERANGE type.Nr!rr<r:rrr"r<rceZdZdZdZdS)r&Represent the PostgreSQL TSRANGE type.Nr!rr<r:rrs00NNNr<rceZdZdZdZdS)r(Represent the PostgreSQL TSTZRANGE type.Nr!rr<r:rrr"r<rceZdZdZdZdS)rz-Represent the PostgreSQL INT4MULTIRANGE type.Nr!rr<r:rr77%NNNr<rceZdZdZdZdS)rz-Represent the PostgreSQL INT8MULTIRANGE type.Nr!rr<r:rrr+r<rceZdZdZdZdS)rz,Represent the PostgreSQL NUMMULTIRANGE type.Nr!rr<r:rrs66$NNNr<rceZdZdZdZdS)rz-Represent the PostgreSQL DATEMULTIRANGE type.Nr!rr<r:rrr+r<rceZdZdZdZdS)rr'Nr!rr<r:rrs00#NNNr<rceZdZdZdZdS)rr)Nr!rr<r:rrs22%NNNr<riir Range[int]r=r4c|jdust|jcxko tknco'|jdupt|jcxko tkncSr?)r/ _min_int_32 _max_int_32r0)rs r:rrsd GtO D{agDDDDDDDD  4@;!'@@@@[@@@@r<r)rr1r=r4)H __future__rrrrrdecimalrtypingrr r r r r rrrrrrrrrrrrrrrrrr sql sql.type_apir utilr! util.typingr" sql.elementsr#r$r%r&r2dc_slotsr dataclassr-rrrXrrrrcrrrrrrrrrrrrr4r3rrr<r:r?s#""""" """"""######))))))******''''''((((((!!!!!!&&&&&&""""""0------######////// WT,- HD!IIHI//d/h//L "L "L "L "L "GBKL "L "0/L "^$$$$$eBi$$$4;;;;;H'+;;;D % % % % %-b 2 % % %F1"5 !%!%!%!%!%xb ':;!%!%!%H/3 !!!!!#C(!!! !!!!!#C(!!!      "7+   !!!!!#D)!!! !(+ !!!!!#H-!!! &&&&&',&&& &&&&&',&&& %%%%%&w/%%% &&&&&'-&&& $$$$$%h/$$$ &&&&&'1&&&   r<