Ë
    ­Œj<B  ã                  ó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	rTd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j^                  f	 	 	 	 	 	 	 d+d$„Zej^                  f	 	 	 	 	 	 	 d+d%„Z0 G d&„ d'ejb                  e.   «      Z2 G d(„ d)ejf                  e.   «      Z3d,d*„Z4y)-é    )ÚannotationsN)ÚAny)ÚIterable)ÚOptional)ÚSequence)ÚTYPE_CHECKING)ÚTypeVar)ÚUnioné   )ÚCONTAINED_BY)ÚCONTAINS)ÚOVERLAPé   )Útypes)Úutil)Ú
expression)Ú	operators)ÚInternalTraversal)ÚDialect)Ú_ColumnExpressionArgument)Ú_TypeEngineArgument)ÚColumnElement)ÚGrouping)ÚBindParameter)ÚOperatorType)Ú_SelectIterable)Ú_BindProcessorType)Ú_LiteralProcessorType)Ú_ResultProcessorType)Ú
TypeEngine)Ú_TraverseInternalsType)ÚSelfÚ_T)Úboundc                ó&   — |j                  | |«      S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.any` method.
    See that method for details.

    )Úany©ÚotherÚarrexprÚoperators      ún/var/www/html/Fitness-lenito-AI-main/venv/lib/python3.12/site-packages/sqlalchemy/dialects/postgresql/array.pyr   r   1   ó   € ð �;‰;�u˜hÓ'Ð'ó    c                ó&   — |j                  | |«      S )zjA synonym for the ARRAY-level :meth:`.ARRAY.Comparator.all` method.
    See that method for details.

    )Úallr'   s      r+   ÚAllr0   >   r,   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

    .. versionadded:: 1.3.6 added support for multidimensional array literals

    .. 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_opr4   r5   ÚsqltypesÚNULLTYPEÚ
isinstanceÚARRAYÚ	item_typer:   )Úselfr4   r7   Ú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© ©rC   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_operatorr7   Ú_compared_to_typeÚunique)Ú_assume_scalarr7   )r   Úgetitemr   r   r5   r2   Ú_bind_param)rC   r*   Úobjr7   rP   Úos         r+   rR   zarray._bind_paramÉ   s‹   € ñ ˜X¬×):Ñ):Ñ:Ü×+Ñ+ØØØ&.ØØ"&§)¡)Øôð ô ñ
 !ó	ñ !˜ð ×$Ñ$Ø  !°DÀð %õ ð !ñ	óð ùòs   ÁA&c                ó’   — |t         j                  t         j                  t         j                  fv rt	        j
                  | «      S | S rH   )r   Úany_opÚall_oprQ   r   r   )rC   Úagainsts     r+   Ú
self_groupzarray.self_groupä   s;   € ð ”y×'Ñ'¬×)9Ñ)9¼9×;LÑ;LÐMÑMÜ×&Ñ& tÓ,Ð,àˆKr-   )r4   zIterable[_T]r7   z!Optional[_TypeEngineArgument[_T]]rD   Ú
typing_Any)Úreturnr   )NF)
r*   r   rS   rZ   r7   zOptional[TypeEngine[_T]]rP   Úboolr[   zBindParameter[_T]rH   )rX   zOptional[OperatorType]r[   zUnion[Self, Grouping[_T]])Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__visit_name__Ústringify_dialectr   Údp_clauseelement_tupleÚdp_typer6   Ú__annotations__r<   ÚpropertyrK   rR   rY   Ú__classcell__)rF   s   @r+   r2   r2   K   sÙ   ø… ñKðZ €Nà$Ðð 
Ð%×<Ñ<Ð=Ø	Ð"×*Ñ*Ð+ð3ÐÐ/ó ð 48ñ	!)àð!)ð 1ð	!)ð
 õ!)ðF òó ðð +/Ø$ðàðð ðð (ð	ð
 ðð 
óð8 15ðØ-ðà	"÷r-   r2   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)rA   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        |t        «      r |«       }|| _        || _        || _        || _        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)r@   rA   Ú
ValueErrorr5   rB   Úas_tupler:   Úzero_indexes)rC   rB   rk   r:   rl   s        r+   r<   zARRAY.__init__5  sQ   € ôN �i¤Ô'Üð?óð ô �i¤Ô&Ù!›ˆIØ"ˆŒØ ˆŒØ$ˆŒØ(ˆÕ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)rC   r(   Úkwargss      r+   ÚcontainszARRAY.Comparator.containsr  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.
            rp   )rr   r   r>   rs   ©rC   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.
            rp   )rr   r   r>   rs   rw   s     r+   ÚoverlapzARRAY.Comparator.overlap…  s   € ð —<‘<¤¨¼H×<LÑ<L�<ÓMÐMr-   N)r(   rZ   rt   rZ   r[   úColumnElement[bool])r(   rZ   r[   r{   )r]   r^   r_   r`   ru   rx   rz   rI   r-   r+   Ú
Comparatorrn   h  s3   „ ñ	ð		OØ#ð		OØ/9ð		Oà ó		Oó	ô	Nr-   r|   c                óz   — t        | j                  t        j                  «      xr | j                  j                  S rH   )r@   rB   r>   ÚEnumÚnative_enumrJ   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 rH   )Ú_apply_item_processorr:   )ÚvalueÚinnerÚ	item_procrC   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�   )rB   Údialect_implÚliteral_processor)rC   Ú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 rH   )rˆ   r:   Úlist©r‰   r‹   rC   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]])rB   r�   Úbind_processor)rC   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 rH   )rˆ   r:   rk   Ú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 rH   )r@   r�   )r‰   r    Úsuper_rps    €€r+   rŒ   z'ARRAY.result_processor.<locals>.process×  sA   ø€ ð �=Ø �Lñ  ä! %¬Ô-ñ & eÓ,óð ð óð r-   )r‰   rŽ   r[   r–   )r‰   r�   r[   ú	list[str])rB   r�   Úresult_processorr€   ÚreÚcompile)rC   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)rB   z_TypeEngineArgument[_T]rk   r\   r:   zOptional[int]rl   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_   r`   r<   r>   rA   r|   r#   Úcomparator_factoryr   Úmemoized_propertyr€   r�   r—   r¤   rI   r-   r+   rA   rA   í   sÅ   „ ñEðT Ø$(Ø"ð1)à*ð1)ð ð1)ð "ð	1)ð
 ó1)ôf!N�X—^‘^×.Ñ.¨rÑ2ô !NðF $Ðà	×Ñò
ó ð
ðØðà	,óð(Øðà	;óð&*Øð*Ø)/ð*à	3ô*r-   rA   c                óf  — d| vr| r| j                  d«      S g S | j                  dd«      }|j                  dd«      }g }t        j                   d|«      }d}|D ]T  }|dk(  r| }Œ|r"|j                  |j                  dd«      «       Œ0|j	                  t        j
                  d	|«      «       ŒV |S )
NÚ"Ú,z\"z_$ESC_QUOTE$_z\\Ú\z(")Fz([^\s,]+),?)ÚsplitÚreplacer¥   ÚappendÚextendÚfindall)Úarray_stringÚtextÚresultÚ	on_quotesÚ	in_quotesÚtoks         r+   rž   rž   è  s°   € Ø
�,Ñá*6ˆ|×!Ñ! #Ó&Ð>¸BÐ>ð ×Ñ  Ó7€DØ�<‰<˜˜tÓ$€DØ€FÜ—‘˜ Ó&€IØ€IÛˆØ�#Š:Ø%˜‰IÙØ�M‰M˜#Ÿ+™+ o°sÓ;Õ<à�M‰Mœ"Ÿ*™* ^°SÓ9Õ:ð ð €Mr-   )r(   rZ   r)   z_ColumnExpressionArgument[_T]r*   r   r[   r{   )r´   r�   r[   r£   )5Ú
__future__r   r¥   Útypingr   rZ   r   r   r   r   r	   r
   r   r   r   r   Ú r   r>   r   Úsqlr   Úsql.visitorsr   Úengine.interfacesr   Úsql._typingr   r   Úsql.elementsr   r   Úsql.expressionr   Úsql.operatorsr   Úsql.selectabler   Úsql.type_apir   r   r   r    r!   Úutil.typingr"   r#   Úeqr0   ÚExpressionClauseListr2   rA   rž   rI   r-   r+   Ú<module>rÉ      s  ðõ #ã 	Ý $Ý Ý Ý Ý  Ý Ý å #Ý Ý Ý !Ý Ý Ý Ý -áÝ,Ý8Ý2Ý-Ý(Ý/Ý-Ý1Ý2Ý5Ý4Ý*Ý6Ý#ñ ˆT˜Ô$€ð 'Ÿ\™\ð
(Øð
(à*ð
(ð ð
(ð ó	
(ð  'Ÿ\™\ð
(Øð
(à*ð
(ð ð
(ð ó	
(ô_ˆJ×+Ñ+¨BÑ/ô _ôDxˆH�N‰N˜2Ñô xôvr-   