rjI~8ddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z!ddl"mZdd 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,ejZd(d()Gd*d+e e+Z.Gd,d-e e.e+Z/Gd.d/e!jLe+Z0Gd0d1e0e.e+Z1Gd2d3e1e+Z2Gd4d5e0ee.e+Z3Gd6d7e3e+Z4Gd8d9e1e5Z6Gd:d;e1e5Z7Gd<d=e1eZ8Gd>d?e1eZ9Gd@dAe1eZ:GdBdCe1eZ;GdDdEe3e5Z<GdFdGe3e5Z=GdHdIe3eZ>GdJdKe3eZ?GdLdMe3eZ@GdNdOe3eZAdPZBdQZCdSdRZDy)T) annotationsN)date)datetime) timedelta)Decimal)Any)cast)Generic)List)Literal)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) OperatorClass) TypeEngine) ColumnElement)_TE)TypeEngineMixin_T)bound)z()[)z(]z[]T)frozenslotsceZdZUdZdZded< dZded< ejddZ d ed <ejd dZ d ed <d+dZ e d+dZ e d+dZe d+dZe d+dZe d+dZe d+dZe d,dZd-dZd.dZ d/ d0dZd1dZd2dZd3dZeZd2dZd2dZeZd2dZeZd2dZ d2d Z! d4d!Z"d2d"Z#d5d#Z$d5d$Z%d5d%Z&d5d&Z'd5d'Z(d5d(Z)d6d)Z*d6d*Z+y)7Rangea_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(T)defaultkw_only _BoundsTypeboundsFboolemptyc|j SNr5selfs p/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/sqlalchemy/dialects/postgresql/ranges.py__bool__zRange.__bool__Ts::~c|jSz$A synonym for the 'empty' attribute.r8r9s r;isemptyz Range.isemptyWzzr=c|jSr?r8r9s r;is_emptyzRange.is_empty]rAr=c&|jddk(S)z,Return True if the lower bound is inclusive.r[r3r9s r; lower_inczRange.lower_incc{{1~$$r=c<|j xr|jduS)zKReturn True if this range is non-empty and lower bound is infinite.N)r5r.r9s r; lower_infzRange.lower_infi ::~4$**"44r=c&|jddk(S)z,Return True if the upper bound is inclusive.r]rFr9s r; upper_inczRange.upper_incprHr=c<|j xr|jduS)zOReturn True if this range is non-empty and the upper bound is infinite.N)r5r/r9s r; upper_infzRange.upper_infvrKr=ctSr7)AbstractSingleRanger9s r;__sa_type_engine__zRange.__sa_type_engine__}s "$$r=c|jry|j@|jduxs0|jddk(r||jkS||jkS|j0|jddk(r||jkDS||jk\S|jddk(r||jkDn||jk\xr0|jddk(r||jkS||jkS)z3Return True if this range contains the given value.FNr)r()r5r.r/r3r:values r;_contains_valuezRange._contains_values  :: :: ::%;;q>S( " djj(  :: ;;q>S( " djj( {{1~$ DJJ $**$ {{1~$ DJJ   $**$ r=cXt|jtst|jtryt|jtst|jtryt|jt st|jt r t dSy)uADetermine the “step” for this range, if it is a discrete one.rN)days) isinstancer.intr/rrrr9s r;_get_discrete_stepzRange._get_discrete_stepsn djj# &*TZZ*E  H - JJ2   D )Z D-I!$ $r=cf|dv}|dv}||cxurnn ||k(ry|rdSdS||rdSdS||rdSdS||k(r||k(ry|dv}|dv} |j} | *|r |s|| z }d}n |r|| z }d}|r | s|| z }d} n | r|| z }d} ||kry||kDry|ry|r| ry|s| s ||k(ry|rdSdS|s|rdSdS| s|rdSdSy)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. >rVrErr>rErMTF)r^) r:value1bound1value2bound2 only_valuesvalue1_is_lower_boundvalue2_is_lower_bound value1_inc value2_incsteps r;_compare_edgeszRange._compare_edgessN"!'* 4 &* 4 V #$(==2r99 ^.2 5A 5 ^-1 52 5 V & 0z) z) &&(  %!dNF!%JdNF!&J$!dNF!%JdNF!&J F? f_  j (,AA 51=2=1q9r92r99r=ct|tstS|jr |jry|j|jk7ry|j}|j d}|j}|j d}|j }|j d}|j }|j d} |j||||dk(xr|j|||| dk(S)zCompare this range to the `other` taking into account bounds inclusivity, returning ``True`` if they are equal. TFrr)r\r,NotImplementedr5r.r3r/rk r:otherslowerslower_bolowerolower_bsuppersupper_boupperoupper_bs r;__eq__z Range.__eq__ s %'! ! ::%++ ZZ5;; &;;q><<?;;q><<?   &( Cq H M##FHfhG1L r=cp|jry|jry|j}|jd}|j}|jd}|j||||dkry|j}|jd}|j}|jd} |j|||| dkDryy)z7Determine whether this range is a contained by `other`.TFrr)r5r.r3rkr/rns r; contained_byzRange.contained_by's :: ;;;;q><<?   vx BQ F;;q><<?   vx BQ Fr=cft|tr|j|S|j|S)z.Determine whether this range contains `value`.)r\r,rzrYrWs r;containszRange.containsDs0 eU #%%d+ +''. .r=c|js |jry|j}|jd}|j}|jd}|j}|jd}|j}|jd} |j ||||dk\r|j |||| dkry|j ||||dk\r|j ||||dkryy)z3Determine whether this range overlaps with `other`.FrrTr5r.r3r/rk r:rorprqrtrurrrsrvrws r;overlapszRange.overlapsNs ::;;q>;;q><<?<<?   &( Cq H##FHfhG1L   &( Cq H##FHfhG1Lr=c|js |jry|j}|jd}|j}|jd}|j ||||dkS)zBDetermine whether this range is completely to the left of `other`.Frr)r5r/r3r.rk)r:rortrurrrss r;strictly_left_ofzRange.strictly_left_ofn^ ::;;q><<?""68VXFJJr=c|js |jry|j}|jd}|j}|jd}|j ||||dkDS)zCDetermine whether this range is completely to the right of `other`.Frrr~)r:rorprqrvrws r;strictly_right_ofzRange.strictly_right_ofrr=c|js |jry|j}|jd}|j}|jd}|j||||dk\S)z>Determine whether this does not extend to the left of `other`.Fr)r5r.r3rk)r:rorprqrrrss r;not_extend_left_ofzRange.not_extend_left_of^ ::;;q><<?""68VXF!KKr=c|js |jry|j}|jd}|j}|jd}|j||||dkS)z?Determine whether this does not extend to the right of `other`.Frr)r5r/r3rk)r:rortrurvrws r;not_extend_right_ofzRange.not_extend_right_ofrr=c<|j||||d}|dk(r<|j}|y|dk(r|dk(r|||z k(S||k(S|dk(r||k(S|||z k(S|dk(rA|dk(r|dk(s |dk(r|dk(r|j}|y|dk(xr|dk(xs |dk(xr|dk(Sy) zTDetermine whether an upper bound is immediately successive to a lower bound.Tr`FrMrErrUrV)rkr^)r:rarbrcrdresrjs r;_upper_edge_adjacent_to_lowerz#Range._upper_edge_adjacent_to_lowers!!&&&&$G "9**,D|}S=!Vd]22!V++S=!V++!Vd]22 AX# cMS=cM..0## "cM"S="cM  r=c`|js |jry|j}|jd}|j}|jd}|j}|jd}|j}|jd} |j ||||xs|j || ||S)z8Determine whether this range is adjacent to the `other`.Frr)r5r.r3r/rrs r; adjacent_tozRange.adjacent_tos ::;;q>;;q><<?<<?11 Hfh   / / Hfh  r=c *|jr|S|jr|S|j|s|j|s td|j}|j d}|j }|j d}|j}|j d}|j }|j d} |j||||dkr|} |} n|} |} |j|||| dkDr|} |} 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 implementedrrrF) r5rr ValueErrorr.r3r/rkr,r r2r:rorprqrtrurrrsrvrwrlowerrlower_brupperrupper_bs r;unionz Range.unions ::L ;;K}}U#D,<,;;q><<?<<?   vx BQ FFHFH   vx BQ FFHFH F4 X5H#I  r=c$|j|Sr7)rr:ros r;__add__z Range.__add__!szz%  r=c |js |jr|S|j}|jd}|j}|jd}|j}|jd}|j}|jd} |j ||||} |j |||| } | dkr| dkDr t d|j |||| } |j ||||} | dkDs| dkr|S| dk\r| dkrt dddS| dkra| dk\r\| dkrW|dk(rdnd }|dk7r*|d k7r%|j ||||dk(rt dddSt ||tt||z S| dk\ra| dk\r\| dkrW| d k(rd nd}|dk7r*|d k7r%|j ||||dk(rt 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 implementedNTr8rErUrMrFrVzUnhandled case computing z - ) r5r.r3r/rkrr,r r2)r:rorprqrtrurrrsrvrwsl_vs_olsu_vs_ousl_vs_ousu_vs_olrrs r; differencezRange.difference$s0 ::K;;q>;;q><<?<<?&&vxJ&&vxJ a;;q><<?<<?   vx BQ FFHFH   vx BQ FFHFH   X%89  r=c$|j|Sr7)rrs r;__mul__z Range.__mul__s  ''r=c"|jSr7) _stringifyr9s r;__str__z Range.__str__s  r=c|jry|j|j}}|dn|}|dn|}td|j\}}||d||S)Nr5zTuple[str, str],)r5r.r/r r3)r:lrb0b1s r;rzRange._stringifysa ::zz4::1)B)B'5BaS!RD!!r=)returnr4)rzAbstractSingleRange[_T])rXr&rr4)rr)F) rar-rbstrrcr-rdrrer4rr])rorrr4)ro Range[_T]rr4)rXzUnion[_T, Range[_T]]rr4) rar-rbrrcr-rdrrr4)rorrr)rr),__name__ __module__ __qualname____doc__r.__annotations__r/ dataclassesfieldr3r5r<propertyr@rCrGrJrNrPrSrYr^rkrxrzr| __contains__rr __lshift__r __rshift__rrrrrrrrrrrrr=r;r,r,4s*E<E<++++D$GFKG#+##E4@E4@  %% 55 %% 55 %% <4" WWW W  W  W Wr 6:/L@ K"J K#J L L--- -  -  -^ ,, \!JCX&$ L(! "r=r,c"eZdZdZeddZy) 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`. ctSr7)AbstractMultiRanger9s r;rSzMultiRange.__sa_type_engine__s !##r=N)rzAbstractMultiRange[_T])rrrrrrSrr=r;rrs($$r=rceZdZdZdZej ZdZe ddZ e d dZ d fd Z Gdde je eZxZS) AbstractRangez0Base class for single and multi Range SQL types.Tc yr7rr:clskws r;adaptzAbstractRange.adapts7:r=c yr7rrs r;rzAbstractRange.adaptsr=c t|ttfr=||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)r:rr visit_namers r;rzAbstractRange.adaptst s46LM N4>>),,J4,i(dnn%!:.  7=% %r=cpeZdZdZddZddZddZddZeZddZ e Z ddZ ddZ dd Z dd Zdd Zdd Zy ) AbstractRange.comparator_factoryz-Define comparison operations for range types.c B|jjt|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)r:rors r;r|z)AbstractRange.comparator_factory.containss99$$Xu5 5r=cB|jjt|S)zsBoolean expression. Returns true if the column is contained within the right hand operand. )rrrrs r;rzz-AbstractRange.comparator_factory.contained_bys99$$\59 9r=cB|jjt|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 s99$$We4 4r=cB|jjt|S)zsBoolean expression. Returns true if the column is strictly left of the right hand operand. )rrrrs r;rz1AbstractRange.comparator_factory.strictly_left_ofs99$$%5u= =r=cB|jjt|S)ztBoolean expression. Returns true if the column is strictly right of the right hand operand. )rrrrs r;rz2AbstractRange.comparator_factory.strictly_right_ofs99$$%6> >r=cB|jjt|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"s99$$%8%@ @r=cB|jjt|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_of(s99$$%7? ?r=cB|jjt|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_to.s99$$[%8 8r=cV|jjtj|SzRange expression. Returns the union of the two ranges. Will raise an exception if the resulting range is not contiguous. )rrr addrs r;rz&AbstractRange.comparator_factory.union4 99$$Y]]E: :r=cV|jjtj|Sr)rrr subrs r;rz+AbstractRange.comparator_factory.difference;rr=cV|jjtj|S)zRange expression. Returns the intersection of the two ranges. Will raise an exception if the resulting range is not contiguous. )rrr mulrs r;rz-AbstractRange.comparator_factory.intersectionBrr=N)rorrrrColumnElement[bool])rorrr)rorrzColumnElement[Range[_T]])rrrrr|rzrrrrrrrrrrrrr=r;comparator_factoryrsL; 6 :  5  > &  ? '  A  @  9  ; ; ;r=r)rz Type[_TE]rrrr$)rzType[TypeEngineMixin]rrrTypeEngine[Any])rz-Type[Union[TypeEngine[Any], TypeEngineMixin]]rrrr)rrrrrender_bind_castr!NUMERICoperator_classes __abstract__rrr" Comparatorr,rr __classcell__)rs@r;rrs:$,,L :: (03  & : & &  &DN;Z225:>N;N;r=rceZdZdZdZddZy)rRzBase for PostgreSQL RANGE types. These are types that return a single :class:`_postgresql.Range` object. .. seealso:: `PostgreSQL range functions `_ Tc|j |jn |j}t|trt |r t St St|ttfr tSt|tr |js tStSt|tr tSt j"Sr7)r.r/r\r] _is_int32 INT4RANGE INT8RANGErfloatNUMRANGErtzinfoTSRANGE TSTZRANGEr DATERANGEsqltypesNULLTYPE)r:rXspecs r;_resolve_for_literalz(AbstractSingleRange._resolve_for_literalWs#kk5u{{5;; dC  {" {" w. /:  h '$(KK79 @Y[ @ d #; $$ $r=N)rXz Range[Any]rrrrrrrrrr=r;rRrRJsL%r=rRceZdZdZy)rzQMarker for AbstractSingleRange that will apply a subclass-specific adaptationNrrrrrr=r;rrmr=rceZdZdZdZddZy)rzBase for PostgreSQL MULTIRANGE types. these are types that return a sequence of :class:`_postgresql.Range` objects. Tc|stjS|d}|j |jn |j}t |t r&t d|Dr tStSt |ttfr tSt |tr |js tStSt |t r t#StjS)Nrc32K|]}t|ywr7)r).0rs r; z:AbstractMultiRange._resolve_for_literal..s/A9Q</s)rrr.r/r\r]allINT4MULTIRANGEINT8MULTIRANGErr NUMMULTIRANGErr TSMULTIRANGETSTZMULTIRANGErDATEMULTIRANGE)r:rXfirstrs r;rz'AbstractMultiRange._resolve_for_literal|s$$ $a#kk5u{{5;; dC ///%''%'' w. / ? " h ')-<> J.:J J d #!# #$$ $r=N)rXzSequence[Range[Any]]rrrrr=r;rrrsL%r=rceZdZdZy)rzPMarker for AbstractMultiRange that will apply a subclass-specific adaptationNrrr=r;rrrr=rceZdZdZdZy)rz(Represent the PostgreSQL INT4RANGE type.Nrrrrrrr=r;rr 2 Nr=rceZdZdZdZy)rz(Represent the PostgreSQL INT8RANGE type.Nrrr=r;rrrr=rceZdZdZdZy)rz'Represent the PostgreSQL NUMRANGE type.Nrrr=r;rrs 1Nr=rceZdZdZdZy)rz(Represent the PostgreSQL DATERANGE type.Nrrr=r;rrrr=rceZdZdZdZy)r&Represent the PostgreSQL TSRANGE type.Nrrr=r;rrs 0Nr=rceZdZdZdZy)r(Represent the PostgreSQL TSTZRANGE type.Nrrr=r;rrrr=rceZdZdZdZy)r z-Represent the PostgreSQL INT4MULTIRANGE type.Nrrr=r;r r  7%Nr=r ceZdZdZdZy)r z-Represent the PostgreSQL INT8MULTIRANGE type.Nrrr=r;r r rr=r ceZdZdZdZy)rz,Represent the PostgreSQL NUMMULTIRANGE type.Nrrr=r;rrs 6$Nr=rceZdZdZdZy)rz-Represent the PostgreSQL DATEMULTIRANGE type.Nrrr=r;rrrr=rceZdZdZdZy)rrNrrr=r;rrs 0#Nr=rceZdZdZdZy)rrNrrr=r;rrs 2%Nr=riic|jduxs"t|jcxkxr tkncxr2|jduxs"t|jcxkxr tkScSr7)r. _min_int_32 _max_int_32r/)rs r;rrsP GGtO D{aggDD  4@;!''@[@@r=)rz Range[int]rr4)E __future__rrrrrdecimalrtypingrr r r r r rrrrrrrr rrrrrrrrrrrsql sql.operatorsr! sql.type_apir" sql.elementsr#r$r%r&r2 dataclassr,rrrRrrrr]rrrrrrr r rrrrr'r&rrr=r;r0s%# "#)*'(!*&-#/ T,- d$/t "GBKt "0t "n$eBi$4A;H''+A;H %-b 2 %F1"5 !%xb ':;!%H/3 !#C(! !#C(!  "7+ !#D)! !(+ !#H-! &',& &',& %&w/% &'-& $%h/$ &'1&   r=