Ë
    3ýjF  ã                  óp  — 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 e	rZd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
d#e¬$«      Z/ e
d%e¬$«      Z0ejb                  f	 	 	 	 	 	 	 d-d&„Zejb                  f	 	 	 	 	 	 	 d-d'„Z2 G d(„ d)ejf                  e/   «      Z4 G d*„ d+ejj                  e/   «      Z5d.d,„Z6y)/é    )ÚannotationsN)ÚAny)ÚIterable)ÚOptional)ÚSequence)ÚTYPE_CHECKING)ÚTypeVar)ÚUnioné   )ÚCONTAINED_BY)ÚCONTAINS)ÚOVERLAPé   )Útypes)Úutil)Ú
expression)Ú	operators)ÚInternalTraversal)ÚDialect)Ú_ColumnExpressionArgument)Ú_CovariantTypeEngineArgument)Ú_TypeEngineArgument)ÚColumnElement)ÚGrouping)ÚBindParameter)ÚOperatorType)Ú_SelectIterable)Ú_BindProcessorType)Ú_LiteralProcessorType)Ú_ResultProcessorType)Ú
TypeEngine)Ú_TraverseInternalsType)ÚSelfÚ_T)ÚboundÚ_CTc                ó&   — |j                  | |«      S )aÌ  A synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method.
    See that method for details.

    .. deprecated:: 2.1

        The :meth:`_types.ARRAY.Comparator.any` and
        :meth:`_types.ARRAY.Comparator.all` methods for arrays are deprecated
        for removal, along with the PG-specific :func:`_postgresql.Any` and
        :func:`_postgresql.All` functions. See :func:`_sql.any_` and
        :func:`_sql.all_` functions for modern use.


    )Úany©ÚotherÚarrexprÚoperators      ú^/root/telegram-saas/.venv/lib/python3.12/site-packages/sqlalchemy/dialects/postgresql/array.pyr   r   3   s   € ð& �;‰;�u˜hÓ'Ð'ó    c                ó&   — |j                  | |«      S )aË  A synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method.
    See that method for details.

    .. deprecated:: 2.1

        The :meth:`_types.ARRAY.Comparator.any` and
        :meth:`_types.ARRAY.Comparator.all` methods for arrays are deprecated
        for removal, along with the PG-specific :func:`_postgresql.Any` and
        :func:`_postgresql.All` functions. See :func:`_sql.any_` and
        :func:`_sql.all_` functions for modern use.

    )Úallr)   s      r-   ÚAllr1   I   s   € ð$ �;‰;�u˜hÓ'Ð'r.   c                  óÄ   ‡ — e Zd ZU dZd ZdZdej                  fdej                  fgZ	de
d<   ddœ	 	 	 	 	 dˆ fd	„Zedd
„«       Z	 	 d	 	 	 	 	 	 	 	 	 dd„Z	 d	 	 	 dd„Zˆ xZS )ÚarrayaŽ  A PostgreSQL ARRAY literal.

    This is used to produce ARRAY literals in SQL expressions, e.g.::

        from sqlalchemy.dialects.postgresql import array
        from sqlalchemy.dialects import postgresql
        from sqlalchemy import select, func

        stmt = select(array([1, 2]) + array([3, 4, 5]))

        print(stmt.compile(dialect=postgresql.dialect()))

    Produces the SQL:

    .. sourcecode:: sql

        SELECT ARRAY[%(param_1)s, %(param_2)s] ||
            ARRAY[%(param_3)s, %(param_4)s, %(param_5)s]) AS anon_1

    An instance of :class:`.array` will always have the datatype
    :class:`_types.ARRAY`.  The "inner" type of the array is inferred from the
    values present, unless the :paramref:`_postgresql.array.type_` keyword
    argument is passed::

        array(["foo", "bar"], type_=CHAR)

    When constructing an empty array, the :paramref:`_postgresql.array.type_`
    argument is particularly important as PostgreSQL server typically requires
    a cast to be rendered for the inner type in order to render an empty array.
    SQLAlchemy's compilation for the empty array will produce this cast so
    that::

        stmt = array([], type_=Integer)
        print(stmt.compile(dialect=postgresql.dialect()))

    Produces:

    .. sourcecode:: sql

        ARRAY[]::INTEGER[]

    As required by PostgreSQL for empty arrays.

    .. versionadded:: 2.0.40 added support to render empty PostgreSQL array
       literals with a required cast.

    Multidimensional arrays are produced by nesting :class:`.array` constructs.
    The dimensionality of the final :class:`_types.ARRAY`
    type is calculated by
    recursively adding the dimensions of the inner :class:`_types.ARRAY`
    type::

        stmt = select(
            array(
                [array([1, 2]), array([3, 4]), array([column("q"), column("x")])]
            )
        )
        print(stmt.compile(dialect=postgresql.dialect()))

    Produces:

    .. sourcecode:: sql

        SELECT ARRAY[
            ARRAY[%(param_1)s, %(param_2)s],
            ARRAY[%(param_3)s, %(param_4)s],
            ARRAY[q, x]
        ] AS anon_1

    .. seealso::

        :class:`_postgresql.ARRAY`

    Ú
postgresqlÚclausesÚtyper"   Ú_traverse_internalsN)Útype_c               ój  •— t        ‰| �  t        j                  g|¢­i |¤Ž |�|n4| j                  r| j                  d   j
                  nt        j                  }t        |t        «      r8t        |j                  |j                  �|j                  dz   nd¬«      | _        yt        |«      | _        y)a  Construct an ARRAY literal.

        :param clauses: iterable, such as a list, containing elements to be
         rendered in the array
        :param type\_: optional type.  If omitted, the type is inferred
         from the contents of the array.

        Nr   r   é   )Ú
dimensions)ÚsuperÚ__init__r   Úcomma_opr5   r6   ÚsqltypesÚNULLTYPEÚ
isinstanceÚARRAYÚ	item_typer;   )Úselfr5   r8   ÚkwÚ	main_typeÚ	__class__s        €r-   r=   zarray.__init__³   s£   ø€ ô 	‰Ñœ×+Ñ+Ð<¨gÒ<¸Ò<ð Ð ñ à)-¯ª�—‘˜a‘×%Ò%¼8×;LÑ;Lð 	ô �i¤Ô'ÜØ×#Ñ#ð !×+Ñ+Ð7ð ×(Ñ(¨1Ò,àôˆD�Iô ˜iÓ(ˆD�Ir.   c                ó   — | fS ©N© ©rD   s    r-   Ú_select_iterablezarray._select_iterableÖ   s	   € àˆwˆr.   c                óÖ   — |s|t         j                  u r%t        j                  d |||| j                  d¬«      S t        |D �cg c]  }| j                  ||d|¬«      ‘Œ c}«      S c c}w )NT)Ú_compared_to_operatorr8   Ú_compared_to_typeÚunique)Ú_assume_scalarr8   )r   Úgetitemr   r   r6   r3   Ú_bind_param)rD   r,   Úobjr8   rQ   Úos         r-   rS   zarray._bind_paramÚ   s„   € ñ ˜X¬×):Ñ):Ñ:Ü×+Ñ+ØØØ&.ØØ"&§)¡)Øôð ô ð
 !ö	ð ð ×$Ñ$Ø  !°DÀð %õ òóð ùòs   ÁA&c                ó’   — |t         j                  t         j                  t         j                  fv rt	        j
                  | «      S | S rI   )r   Úany_opÚall_oprR   r   r   )rD   Úagainsts     r-   Ú
self_groupzarray.self_groupõ   s;   € ð ”y×'Ñ'¬×)9Ñ)9¼9×;LÑ;LÐMÑMÜ×&Ñ& tÓ,Ð,àˆKr.   )r5   zIterable[_T]r8   z!Optional[_TypeEngineArgument[_T]]rE   Ú
typing_Any)Úreturnr   )NF)
r,   r   rT   r[   r8   zOptional[TypeEngine[_T]]rQ   Úboolr\   zBindParameter[_T]rI   )rY   zOptional[OperatorType]r\   zUnion[Self, Grouping[_T]])Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__visit_name__Ústringify_dialectr   Údp_clauseelement_tupleÚdp_typer7   Ú__annotations__r=   ÚpropertyrL   rS   rZ   Ú__classcell__)rG   s   @r-   r3   r3   ^   sÙ   ø… ñIðV €Nà$Ðð 
Ð%×<Ñ<Ð=Ø	Ð"×*Ñ*Ð+ð3ÐÐ/ó ð 48ñ	!)àð!)ð 1ð	!)ð
 õ!)ðF òó ðð +/Ø$ðàðð ðð (ð	ð
 ðð 
óð8 15ðØ-ðà	"÷r.   r3   c                  óÐ   — e Zd ZdZ	 	 	 d
	 	 	 	 	 	 	 dd„Z G d„ dej                  j                  e   «      ZeZ	e
j                  dd„«       Z	 	 	 	 dd„Z	 	 	 	 dd„Z	 	 	 	 	 	 dd	„Zy)rB   an
  PostgreSQL ARRAY type.

    The :class:`_postgresql.ARRAY` type is constructed in the same way
    as the core :class:`_types.ARRAY` type; a member type is required, and a
    number of dimensions is recommended if the type is to be used for more
    than one dimension::

        from sqlalchemy.dialects import postgresql

        mytable = Table(
            "mytable",
            metadata,
            Column("data", postgresql.ARRAY(Integer, dimensions=2)),
        )

    The :class:`_postgresql.ARRAY` type provides all operations defined on the
    core :class:`_types.ARRAY` type, including support for "dimensions",
    indexed access, and simple matching such as
    :meth:`.types.ARRAY.Comparator.any` and
    :meth:`.types.ARRAY.Comparator.all`.  :class:`_postgresql.ARRAY`
    class also
    provides PostgreSQL-specific methods for containment operations, including
    :meth:`.postgresql.ARRAY.Comparator.contains`
    :meth:`.postgresql.ARRAY.Comparator.contained_by`, and
    :meth:`.postgresql.ARRAY.Comparator.overlap`, e.g.::

        mytable.c.data.contains([1, 2])

    Indexed access is one-based by default, to match that of PostgreSQL;
    for zero-based indexed access, set
    :paramref:`_postgresql.ARRAY.zero_indexes`.

    Additionally, the :class:`_postgresql.ARRAY`
    type does not work directly in
    conjunction with the :class:`.ENUM` type.  For a workaround, see the
    special type at :ref:`postgresql_array_of_enum`.

    .. container:: topic

        **Detecting Changes in ARRAY columns when using the ORM**

        The :class:`_postgresql.ARRAY` type, when used with the SQLAlchemy ORM,
        does not detect in-place mutations to the array. In order to detect
        these, the :mod:`sqlalchemy.ext.mutable` extension must be used, using
        the :class:`.MutableList` class::

            from sqlalchemy.dialects.postgresql import ARRAY
            from sqlalchemy.ext.mutable import MutableList


            class SomeOrmClass(Base):
                # ...

                data = Column(MutableList.as_mutable(ARRAY(Integer)))

        This extension will allow "in-place" changes such to the array
        such as ``.append()`` to produce events which will be detected by the
        unit of work.  Note that changes to elements **inside** the array,
        including subarrays that are mutated in place, are **not** detected.

        Alternatively, assigning a new array value to an ORM element that
        replaces the old one will always trigger a change event.

    .. seealso::

        :class:`_types.ARRAY` - base array type

        :class:`_postgresql.array` - produces a literal array value.

    Nc                ó˜   — t        |t        «      rt        d«      ‚t        j                  |«      | _        || _        || _        || _        y)a-  Construct an ARRAY.

        E.g.::

          Column("myarray", ARRAY(Integer))

        Arguments are:

        :param item_type: The data type of items of this array. Note that
          dimensionality is irrelevant here, so multi-dimensional arrays like
          ``INTEGER[][]``, are constructed as ``ARRAY(Integer)``, not as
          ``ARRAY(ARRAY(Integer))`` or such.

        :param as_tuple=False: Specify whether return results
          should be converted to tuples from lists. DBAPIs such
          as psycopg2 return lists by default. When tuples are
          returned, the results are hashable.

        :param dimensions: if non-None, the ARRAY will assume a fixed
         number of dimensions.  This will cause the DDL emitted for this
         ARRAY to include the exact number of bracket clauses ``[]``,
         and will also optimize the performance of the type overall.
         Note that PG arrays are always implicitly "non-dimensioned",
         meaning they can store any number of dimensions no matter how
         they were declared.

        :param zero_indexes=False: when True, index values will be converted
         between Python zero-based and PostgreSQL one-based indexes, e.g.
         a value of one will be added to all index values before passing
         to the database.

        zUDo not nest ARRAY types; ARRAY(basetype) handles multi-dimensional arrays of basetypeN)	rA   rB   Ú
ValueErrorr?   Úto_instancerC   Úas_tupler;   Úzero_indexes)rD   rC   rm   r;   rn   s        r-   r=   zARRAY.__init__F  sK   € ôN �i¤Ô'Üð?óð ô "×-Ñ-¨iÓ8ˆŒØ ˆŒØ$ˆŒØ(ˆÕr.   c                  ó4   — e Zd ZdZ	 	 	 	 	 	 dd„Zdd„Zdd„Zy)úARRAY.Comparatora*  Define comparison operations for :class:`_types.ARRAY`.

        Note that these operations are in addition to those provided
        by the base :class:`.types.ARRAY.Comparator` class, including
        :meth:`.types.ARRAY.Comparator.any` and
        :meth:`.types.ARRAY.Comparator.all`.

        c                óN   — | j                  t        |t        j                  ¬«      S )zåBoolean expression.  Test if elements are a superset of the
            elements of the argument array expression.

            kwargs may be ignored by this operator but are required for API
            conformance.
            ©Úresult_type)Úoperater   r?   ÚBoolean)rD   r*   Úkwargss      r-   ÚcontainszARRAY.Comparator.contains�  s   € ð —<‘<¤¨%¼X×=MÑ=M�<ÓNÐNr.   c                óN   — | j                  t        |t        j                  ¬«      S )z„Boolean expression.  Test if elements are a proper subset of the
            elements of the argument array expression.
            rr   )rt   r   r?   ru   ©rD   r*   s     r-   Úcontained_byzARRAY.Comparator.contained_byŒ  s'   € ð —<‘<Ü˜e´×1AÑ1Að  ó ð r.   c                óN   — | j                  t        |t        j                  ¬«      S )zuBoolean expression.  Test if array has elements in common with
            an argument array expression.
            rr   )rt   r   r?   ru   ry   s     r-   ÚoverlapzARRAY.Comparator.overlap”  s   € ð —<‘<¤¨¼H×<LÑ<L�<ÓMÐMr.   N)r*   r[   rv   r[   r\   úColumnElement[bool])r*   r[   r\   r}   )r^   r_   r`   ra   rw   rz   r|   rJ   r.   r-   Ú
Comparatorrp   w  s3   „ ñ	ð		OØ#ð		OØ/9ð		Oà ó		Oó	ô	Nr.   r~   c                óz   — t        | j                  t        j                  «      xr | j                  j                  S rI   )rA   rC   r?   ÚEnumÚnative_enumrK   s    r-   Ú_against_native_enumzARRAY._against_native_enumœ  s-   € ô �t—~‘~¤x§}¡}Ó5ò +Ø—‘×*Ñ*ð	
r.   c                ó~   ‡ ‡‡— ‰ j                   j                  |«      j                  |«      Š‰€y dd„Šdˆˆ ˆfd„}|S )Nc                ó,   — ddj                  | «      › d�S )NzARRAY[z, ú])Újoin)Úelementss    r-   Úto_strz'ARRAY.literal_processor.<locals>.to_str¬  s   € Ø˜DŸI™I hÓ/Ð0°Ð2Ð2r.   c                óD   •— ‰j                  | ‰‰j                  ‰«      }|S rI   )Ú_apply_item_processorr;   )ÚvalueÚinnerÚ	item_procrD   rˆ   s     €€€r-   Úprocessz(ARRAY.literal_processor.<locals>.process¯  s'   ø€ Ø×.Ñ.Ø�y $§/¡/°6óˆEð ˆLr.   )r‡   zIterable[typing_Any]r\   Ústr)r‹   úSequence[typing_Any]r\   r�   )rC   Údialect_implÚliteral_processor)rD   ÚdialectrŽ   r�   rˆ   s   `  @@r-   r’   zARRAY.literal_processor£  sC   ú€ ð —N‘N×/Ñ/°Ó8×JÑJØó
ˆ	ð ÐØó	3÷	ð ˆr.   c                ót   ‡ ‡— ‰ j                   j                  |«      j                  |«      Š	 	 	 	 dˆˆ fd„}|S )Nc                óP   •— | €| S ‰j                  | ‰‰j                  t        «      S rI   )rŠ   r;   Úlist©r‹   r�   rD   s    €€r-   rŽ   z%ARRAY.bind_processor.<locals>.process¾  s/   ø€ ð ˆ}Ø�à×1Ñ1Ø˜9 d§o¡o´tóð r.   )r‹   úOptional[Sequence[typing_Any]]r\   zOptional[list[typing_Any]])rC   r‘   Úbind_processor)rD   r“   rŽ   r�   s   `  @r-   r™   zARRAY.bind_processor·  sC   ù€ ð —N‘N×/Ñ/°Ó8×GÑGØó
ˆ	ð	Ø1ð	à'ö	ð ˆr.   c                óä   ‡ ‡‡‡‡— ‰ j                   j                  |«      j                  ||«      Š	 	 	 	 dˆˆ fd„}‰ j                  r(|Št	        j
                  d«      Šdˆfd„Š	 	 	 	 dˆˆfd„}|S )Nc                ó|   •— | €| S ‰j                  | ‰‰j                  ‰j                  r
t        «      S t        «      S rI   )rŠ   r;   rm   Útupler–   r—   s    €€r-   rŽ   z'ARRAY.result_processor.<locals>.processÑ  sG   ø€ ð ˆ}Ø�à×1Ñ1ØØØ—O‘OØ!Ÿ]š]”Eó	ð ô 15ó	ð r.   z^{(.*)}$c                óZ   •— ‰j                  | «      j                  d«      }t        |«      S )Nr   )ÚmatchÚgroupÚ_split_enum_values)r‹   rŒ   Úpatterns     €r-   Úhandle_raw_stringz1ARRAY.result_processor.<locals>.handle_raw_stringâ  s'   ø€ ØŸ™ eÓ,×2Ñ2°1Ó5�Ü)¨%Ó0Ð0r.   c                óT   •— | €| S  ‰t        | t        «      r ‰| «      «      S | «      S rI   )rA   r�   )r‹   r¢   Úsuper_rps    €€r-   rŽ   z'ARRAY.result_processor.<locals>.processæ  sA   ø€ ð �=Ø �Lñ  ä! %¬Ô-ñ & eÓ,óð ð óð r.   )r‹   r�   r\   r˜   )r‹   r�   r\   úSequence[Optional[str]])rC   r‘   Úresult_processorr‚   ÚreÚcompile)rD   r“   ÚcoltyperŽ   r¢   r�   r¡   r¤   s   `   @@@@r-   r¦   zARRAY.result_processorÊ  s}   ü€ ð —N‘N×/Ñ/°Ó8×IÑIØ�Wó
ˆ	ð	Ø'ð	à+ö	ð ×$Ò$ØˆHÜ—j‘j Ó-ˆGõ1ðØ+ðà/öð ˆr.   )FNF)rC   z _CovariantTypeEngineArgument[_T]rm   r]   r;   zOptional[int]rn   r]   )r\   r]   )r“   r   r\   z#Optional[_LiteralProcessorType[_T]])r“   r   r\   z2Optional[_BindProcessorType[Sequence[typing_Any]]])r“   r   r©   Úobjectr\   z*_ResultProcessorType[Sequence[typing_Any]])r^   r_   r`   ra   r=   r?   rB   r~   r&   Úcomparator_factoryr   Úmemoized_propertyr‚   r’   r™   r¦   rJ   r.   r-   rB   rB   þ   sÅ   „ ñEðT Ø$(Ø"ð/)à3ð/)ð ð/)ð "ð	/)ð
 ó/)ôb!N�X—^‘^×.Ñ.¨sÑ3ô !NðF $Ðà	×Ñò
ó ð
ðØðà	,óð(Øðà	;óð&*Øð*Ø)/ð*à	3ô*r.   rB   c                óÎ  — d| vr*| r| j                  d«      ng D �cg c]  }|dk7  r|nd ‘Œ c}S | j                  dd«      }|j                  dd«      }g }t        j                   d|«      }d	}|D ]i  }|dk(  r| }Œ|r"|j                  |j                  dd«      «       Œ0|j	                  t        j
                  d
|«      D �cg c]  }|dk7  r|nd ‘Œ c}«       Œk |S c c}w c c}w )Nú"ú,ÚNULLz\"z_$ESC_QUOTE$_z\\ú\z(")Fz([^\s,]+),?)ÚsplitÚreplacer§   ÚappendÚextendÚfindall)Úarray_stringÚrÚtextÚresultÚ	on_quotesÚ	in_quotesÚtoks          r-   r    r    ÷  s  € Ø
�,Ññ 2>�l×(Ñ(¨Ô-À2ö
àð �f’‰A $Ñ&ò
ð 	
ð ×Ñ  Ó7€DØ�<‰<˜˜tÓ$€DØ€FÜ—‘˜ Ó&€IØ€IØò ˆØ�#Š:Ø%˜‰IÙØ�M‰M˜#Ÿ+™+ o°sÓ;Õ<ð �M‰Mô  ŸZ™Z¨¸Ó<öàð ˜fš‘A¨$Ñ.òõðð €Mùò7
ùò,s   œCÃC"
)r*   r[   r+   z_ColumnExpressionArgument[_T]r,   r   r\   r}   )r·   r�   r\   r¥   )7Ú
__future__r   r§   Útypingr   r[   r   r   r   r   r	   r
   r   r   r   r   Ú r   r?   r   Úsqlr   Úsql.visitorsr   Úengine.interfacesr   Úsql._typingr   r   r   Úsql.elementsr   r   Úsql.expressionr   Úsql.operatorsr   Úsql.selectabler   Úsql.type_apir   r   r    r!   r"   Úutil.typingr#   r$   r&   Úeqr1   ÚExpressionClauseListr3   rB   r    rJ   r.   r-   ú<module>rÍ      s  ðõ #ã 	Ý $Ý Ý Ý Ý  Ý Ý å #Ý Ý Ý !Ý Ý Ý Ý -áÝ,Ý8Ý;Ý2Ý-Ý(Ý/Ý-Ý1Ý2Ý5Ý4Ý*Ý6Ý#ñ ˆT˜Ô$€Ùˆe˜:Ô&€ð 'Ÿ\™\ð(Øð(à*ð(ð ð(ð ó	(ð2 'Ÿ\™\ð(Øð(à*ð(ð ð(ð ó	(ô*]ˆJ×+Ñ+¨BÑ/ô ]ô@vˆH�N‰N˜2Ñô vôrr.   