,h/*SrSSKJr SSKJr SSKrSSKrSSKrSSKrSSKJ r SSKJ r SSKJ r SSKJ r SS KJ r SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r SSK!J"r" SSK!J#r# SSK!J$r$ SS K J%r% SS!K J&r& SS"K'J(r( SS#K)J*r* SS$K)J+r+ \R0(d\((dSS%K,J-r- OSS%K.J-r- \R0(a SS&K/J0r0 SS'K1J2r2 \\3S(4r4\\4\54r6\ r7\\4\74r8\\\ \\ 4r9\\ S)4r:\"S*\9S+9r;\"S,\ S+9r<\"S-\\ S)4S+9r=\\;\:4r>\\\ \ 4r?\\S.r@\ \\ /\\ 4rA\ \ /\ 4rB\\\ \\B4rC"S/S05rD"S1S2\R\ 5rF"S3S4\D5rGSOSPS5jjrH"S6S7\5rI\IRrJ"S8S9\$\ \;5rK"S:S;5rL"S<S=\L\K\\=5rM"S>S?\K\;5rN"S@SA\N\;5rO"SBSC\N\;\ R5rQ"SDSE\L\N\5rR"SFSG\ \=5rS"SHSI\M\=5rTSQSJjrU"SKSL\T\=5rV"SMSN\T\=5rWg)Rz%Define generic result set constructs.) annotations)EnumN)Any)Callable)cast)Dict)Generic)Iterable)Iterator)List)Mapping)NoReturn)Optional)overload)Sequence)Set)Tuple) TYPE_CHECKING)TypeVar)Union)Row) RowMapping)exc)util) _generative) HasMemoized)InPlaceGenerative)!HasMemoized_ro_memoized_attribute)NONE_SET)HAS_CYEXTENSION)Literal)Self) tuplegetter)SQLCoreOperations)_ResultProcessorTypezSQLCoreOperations[Any]._R)bound_T_TPz_ResultProcessorType[Any]c\rSrSr%SrSrSrS\S'SrS\S'Sr S \S 'S \S 'S \S'S\S'S\S'\ S$Sj5r S%Sjr S&Sjr \S'S(Sjj5r\S'S)Sjj5r\S'S*Sjj5rS+S*SjjrS,SjrS-SjrS.SjrS/SjrS0SjrS+S1SjjrS2S jrS3S!jrS4S"jr\ S5S#j5rSrg)6ResultMetaData]z$Base for metadata about result rows.NOptional[_TupleGetterType] _tuplefilterOptional[Sequence[int]]_translated_indexes(Optional[Sequence[Callable[[Any], Any]]]_unique_filters _KeyMapType_keymap Sequence[str]_keysOptional[_ProcessorsType] _processorsMapping[_KeyType, int] _key_to_indexc[U5$N) RMKeyViewselfs P/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/engine/result.pykeysResultMetaData.keysjs c[5er?NotImplementedErrorrBkeys rC_has_keyResultMetaData._has_keyn !##rFc[5er?rHrAs rC _for_freezeResultMetaData._for_freezeqrNrFcgr?r/rBrKerrraiseerrs rC _key_fallbackResultMetaData._key_fallbacktsrFcgr?r/rSs rCrVrWys rFcgr?r/rSs rCrVrWs!rFc,U(de[U5Uer?)KeyErrorrSs rCrVrWsxsm$rFc[S5e)NzCambiguous column name logic is implemented for CursorResultMetaDatarH)rBrecs rC _raise_for_ambiguous_column_name/ResultMetaData._raise_for_ambiguous_column_names" #  rFc[5er?rHrBrKrUs rC_index_for_keyResultMetaData._index_for_key "##rFc[5er?rHrBrDs rC_indexes_for_keys ResultMetaData._indexes_for_keysrdrFc[5er?rHrfs rC_metadata_for_keys!ResultMetaData._metadata_for_keysrdrFc[5er?rHrfs rC_reduceResultMetaData._reducerNrFcXURX5nUb[R"U5$gr?)rboperator itemgetter)rBrKrUindexs rC_getterResultMetaData._getters.##C2  &&u- -rFc4URU5n[U6$r?)rgr%)rBrDindexess rC_row_as_tuple_getter#ResultMetaData._row_as_tuple_getters((.G$$rFclUR5VVs0sHup4XBcM X4U_M snn$s snnfr?)items)rBkeymaprrrKr]s rC_make_key_to_index!ResultMetaData._make_key_to_indexs> #LLN *z CUO*   s 0 0cXR;aURURU5 gU(aURUS5 gURUS5 g![an[ UR S5UeSnAff=fNr)r7r^rVr[AttributeErrorargs)rBrK attr_errorkes rC_key_not_foundResultMetaData._key_not_foundsv ,,   1 1$,,s2C D=&&sD1""3- =(4"<=sA B'BBcUR(a%[R"UR5(agUR$r?)r;r! issupersetrAs rC_effective_processors$ResultMetaData._effective_processorss08#6#6t7G7G#H#H## #rFreturnr@rKobjectrboolrr-).)rKrrTOptional[Exception]rU Literal[True]rr)rKrrTrrUzLiteral[False]rNone)rKrrTrrUrrzOptional[NoReturn]T)r]_KeyMapRecTyperr)rK _KeyIndexTyperUrr Optional[int])rDSequence[_KeyIndexType]r Sequence[int])rDrrIterator[_KeyMapRecType])rDrrr-)rKrrUrr#Optional[Callable[[Row[Any]], Any]]rDrr_TupleGetterType)r{z Mapping[_KeyType, Sequence[Any]]rrintrr<)rKrrrrr)rr:)__name__ __module__ __qualname____firstlineno____doc__ __slots__r1__annotations__r3r5propertyrDrLrPrrVr^rbrgrjrmrsrwr|rr__static_attributes__r/rFrCr-r-]s.I/3L,33707@DO=D  **)) $$LO0DGvR8&).O J$-TZZ#8#8KE5+,#8  3=M*YTS*M &!44T\\1E# Ns "C2 C9(C?cXR;$r?r7rJs rCrLSimpleResultMetaData._has_key'sll""rFcURnU(a"UR(aURU5n[URURVs/sHo RUSPM snUS9$s snf)Nr)rr5)r5r1rr9r7)rBunique_filtersrKs rCrP SimpleResultMetaData._for_freeze*sf-- d//!..~>N$ JJ37::>:C<<$Q':>*  >sA5 c4URURS.$)Nr9r3rrAs rC __getstate__!SimpleResultMetaData.__getstate__7sZZ#'#;#;  rFcbUS(aUSn[U6nOS=p#URUSUUS9 g)Nr3r9)r3r1)r%r)rBstater3r1s rC __setstate__!SimpleResultMetaData.__setstate__=sI & '"'(="> &(;T"XX#45$r?r/)metadata processors key_to_index scalar_obj_procs rC process_row/ResultInternal._row_getter..process_rows ! lMrFc >T"T"U55$r?r/)row_make_row_origfixed_tfs rCmake_row,ResultInternal._row_getter..make_rows%hsm44rFc >T"T"U55$r?r/)r,_log_row _make_rows rCr/r0s #//rF) r$r-r%r:r&r<r'rrzRow[Any])r,z_InterimRowType[Row[Any]]rr() rrr rrr r=rr1rrr) rB real_resultr)r$r&r%tfr/r2r3r-r(r.s @@@@@rC _row_getterResultInternal._row_getters-     mT*   / /&&, 9#9!$   K>>-- 33  " " k:: ^ 090A0Az1NH 5 5!((zH  & &"22H I 0 0rFc^^^^URmURmUR(aURummSUUUU4SjjnU$SUU4SjjnU$)Nc3># UR5HQnT(aT"U5OUnT(aT"U5OUnUT;aM-TRU5 T(aT"U5nUv MS g7fr?)r add)rBraw_rowobjhashedr/post_creational_filterstrategyuniquess rCiterrows1ResultInternal._iterator_getter..iterrowssb#335G-5)7/7Xc]CF( KK'-4S9I 6sA'A*c3># UR5H'nT(aT"U5OUnT(aT"U5nUv M) g7fr?)r )rBr;r,r/r>s rCrArBs>#335G-5)7.4S9I 6s=A)rBr"r Iterator[_R]r6r r_unique_strategy)rBrAr/r>r?r@s @@@@rC_iterator_getterResultInternal._iterator_gettersU##!%!=!=  $ $ $ 5 5 GX  0  rFc~URnUceUR5nUVs/sH o1"U5PM sn$s snfr?)r6r)rBr/rowsr,s rC _raw_all_rowsResultInternal._raw_all_rowssC#####""$)-.# ...s:cURnURnUR5nU(aUVs/sH oB"U5PM nnOUnUR(afURupgUVs/sHnUU(aU"U5OU4PM snVV s/sH&upX;dM UR U 5(aM$UPM( n nn OUn U(aU Vs/sH oA"U5PM n nU $s snfs snfs sn nfs snfr?)r r6rrrFr:) rBr>r/rJr, made_rowsr@r?made_rowsig_row interim_rowss rC_allrowsResultInternal._allrowss!%!=!=##""$ 267$3#$I7II  $ $ $ 5 5 G%. * %.!.6*H%. * *%H)3:++g2F*  L%L !7C7C&s+| 78* s#C#-C( C-C-7C-C3c^^^^URmURmUR(aURummSUUUU4SjjnU$SUU4SjjnU$)Nc>URnU"5nUc[$T(aT"U5OUnT(aT"U5OUnUT;aM;TRU5 T(aT"U5nU$r?)rrr:) rB_onerowr,r<r=r/r>r?r@s rConerow-ResultInternal._onerow_getter..onerowOsl--!)C{&.6HSM33;#!W,$#KK/1"8"=C" rFcz>UR5nUc[$T(aT"U5OUnT(aT"U5nU$r?)rr)rBr, interim_rowr/r>s rCrWrXdsB))+;"N*2 s .&<[&I &&rF)rBr"rzUnion[_NoRow, _R]rE)rBrWr/r>r?r@s @@@@rC_onerow_getterResultInternal._onerow_getterDsX##!%!=!=  $ $ $ 5 5 GX # #B  ' ' rFc^^^^^URmURmUR(a2URummSSjmSUUUUU4SjjnU$SUU4SjjnU$)Nc^U(aUVs/sH o@"U5PM nnT(a U4SjU5nO SU5nUVVs/sH&upgXs;dM URU5(aM$UPM( snn$s snfs snnf)Nc36># UHoT"U54v M g7fr?r/).0rOr?s rC EResultInternal._manyrow_getter..filterrows..s!GK88H#56tsc3(# UHoU4v M g7fr?r/)r`rOs rCrarbs Kd(H!5ds)r:)r/rJr?r@r,rNrOrPs ` rC filterrows2ResultInternal._manyrow_getter..filterrows{s 59:TcHSMTD:!GK!I!Ld KI.7-6)-6=kk'6J-6;sA3 A8A8)A8c">/nURnUcUR(a URO [SU5nUR(aUR=pQOCU"U5n[ U5nT ceUR T"T UT T 55 U[ U5- nOUnUceU(aAU"U5nU(dO1UR T"T UT T 55 U[ U5- nU(aMAT (aUVs/sH nT "U5PM nnU$s snfNr")rrr _yield_perrextend) rBnumcollect _manyrowsr4 num_requiredrJr,rdr/r>r?r@s rCmanyrows0ResultInternal._manyrow_getter..manyrowss%' 00 ; ,,))!-6 #---8-C-CC s(~!$i'333&xxI(+S\'9 #&L&"$\2DNN"8T8WE$'W#5L#l*FMNgs5c:gGNOs6D c*>Uc5UR(a URO [SU5nURnURU5nT(aUVs/sH nT"U5PM nnT(aUVs/sH nT"U5PM nnU$s snfs snfrg)rrrhr)rBrjr4rJr,r/r>s rCrnros; ,,))!-6 &00C373G3G3L59:TcHSMTD:)CGH4C2374DH ;Hs B 5B) r/Optional[Callable[..., _R]]rJz List[Any]r?z$Optional[Callable[[List[Any]], Any]]r@zSet[Any]rList[_R])rBzResultInternal[_R]rjrrrrrE)rBrnrdr/r>r?r@s @@@@@rC_manyrow_getterResultInternal._manyrow_getterrs##!%!=!=  $ $ $ 5 5 GX 5  ? "     *- (- /<- - - F% ( /<   $rFcgr?r/rBraise_for_second_rowraise_for_nonescalars rC _only_one_rowResultInternal._only_one_rows rFcgr?r/rvs rCrzr{s rFcgr?r/rvs rCrzr{s rFcbURnU"SS9nUcU(a[R"S5egU(aUR(a SUlSnO UR nU(aU"U5OUnU(aUR(ajURupxU(aU"U5OUn U"SS9n U c[n OIU(aU"U 5OU n U(aU [LdeX"U 5:XaMBOXZ:XaMJOU"SS9n U c[n U [La2UR SS9 [R"U(aS5eS5eOUR SS9 U(dURn U (aU "U5nU(a U(aUS$U$! UR SS9 e=f! UR SS9 e=f) NTrz&No row was found when one was requiredFrz6Multiple rows were found when exactly one was requiredz6Multiple rows were found when one or none was requiredr) rr NoResultFoundr rr6rrrFrMultipleResultsFoundr ) rBrwrxryrWr,r/r@r?existing_row_hashnext_rowr>s rCrzr{s $$.4.E ;''< d33"'D H''H #+(3-C ((%)$9$9!5=HSM3!$*d$;H'#* 9A8H#5x##+7#::#:0HX4FF ( G _$ "T2#&Hw&  d +..%M#'   $  '%)%A%A "%,S1 hq6MJu    $  ' 6((d(3s#F=.F-FFF.c$URU5$r?)rGrAs rC _iter_implResultInternal._iter_implBs$$T**rFcNURU5nU[La [5eU$r?)r[r StopIterationrBr,s rC _next_implResultInternal._next_implEs&!!$' '>/ !JrFcUR(a URO [SU5nUR(a[U5S:wa URR U5UlUR (deU$)Nr"r)rrr rr rmr)rBrvr4s rC_column_slicesResultInternal._column_slicesLsg     mT*  33s7|q7H!^^33G>99!<  ..88>>.."nn99'BG#001DgN  rF)rr rz#Iterator[_InterimRowType[Row[Any]]]Frrrz#Optional[_InterimRowType[Row[Any]]]r?rrrList[_InterimRowType[Row[Any]]]rrrrrr)rrq)rzCallable[..., Iterator[_R]])rrr)rz1Callable[..., Union[Literal[_NoRow._NO_ROW], _R]])rzCallable[..., List[_R]]) rBzResultInternal[Row[Any]]rwrrxrryrrr)rwrrxrryrrr()rwrrxrryrr Optional[_R]rrDrr()rvrrr$)r_UniqueFilterStateType)!rrrrrrrrrr  _is_cursorr rrrrr r6rGrKrRr[rsrrzrrrrrmemoized_attributerFrr/rFrCrrsI*.L'.ND33=A:A>B;BJ""$"'$$ ,$ %)$!$ ($ $$'9'9v' ' D/ #J'+ :+'+Z'`'`D&"  "&  "   S"SS S  Sj+  ##!$!rFrc.\rSrSr%SrS\S'SSjrSrg) _WithKeysiur/r-r c.URR$)aReturn an iterable view which yields the string keys that would be represented by each :class:`_engine.Row`. The keys can represent the labels of the columns returned by a core statement or the names of the orm classes returned by an orm execution. The view also can be tested for key containment using the Python ``in`` operator, which will test both for the string keys represented in the view, as well as for alternate keys such as column objects. .. versionchanged:: 1.4 a key view object is returned rather than a plain list. )r rDrAs rCrD_WithKeys.keys{s"~~"""rFNr)rrrrrrrDrr/rFrCrrusI#rFrc\rSrSr%SrSrSrS\S'SrS\S 'Sr S \S '\ R"5r S \S 'S7Sjr S8SjrS9SjrS:Sjr\S;Sj5r\S;Sj5r\SSjj5rS?Sjr\S@Sj5r\SASj5r\SBSCSjj5rSBSCSjjrSDSESjjrSFSjrSGSjr\SHSj5rSHSjrSIS jrSJS!jr SKS"jr!S=SLS#jjr"SMS$jr#SNS%jr$S=SOS&jjr%SMS'jr&SNS(jr'SNS)jr(\SPS*j5r)\SQS+j5r)SQS,jr)\SRS-j5r*\SSS.j5r*SSS/jr*SKS0jr+\SRS1j5r,\SQS2j5r,SQS3jr,STS4jr-SUS5jr.S6r/g)VResultiaRepresent a set of database results. .. versionadded:: 1.4 The :class:`_engine.Result` object provides a completely updated usage model and calling facade for SQLAlchemy Core and SQLAlchemy ORM. In Core, it forms the basis of the :class:`_engine.CursorResult` object which replaces the previous :class:`_engine.ResultProxy` interface. When using the ORM, a higher level object called :class:`_engine.ChunkedIteratorResult` is normally used. .. note:: In SQLAlchemy 1.4 and above, this object is used for ORM results returned by :meth:`_orm.Session.execute`, which can yield instances of ORM mapped objects either individually or within tuple-like rows. Note that the :class:`_engine.Result` object does not deduplicate instances or rows automatically as is the case with the legacy :class:`_orm.Query` object. For in-Python de-duplication of instances or rows, use the :meth:`_engine.Result.unique` modifier method. .. seealso:: :ref:`tutorial_fetching_rows` - in the :doc:`/tutorial/index` )r __dict__Nz(Optional[Callable[[Row[Any]], Row[Any]]]rFrr rrhzutil.immutabledict[Any, Any] _attributescXlgr?)r )rBcursor_metadatas rCrResult.__init__s(rFcU$r?r/rAs rC __enter__Result.__enter__ rFc$UR5 gr?)closerBtype_value tracebacks rC__exit__Result.__exit__s  rFc"URSS9 g)aclose this :class:`_engine.Result`. The behavior of this method is implementation specific, and is not implemented by default. The method should generally end the resources in use by the result object and also cause any subsequent iteration or row fetching to raise :class:`.ResourceClosedError`. .. versionadded:: 1.4.27 - ``.close()`` was previously not generally available for all :class:`_engine.Result` classes, instead only being available on the :class:`_engine.CursorResult` returned for Core statement executions. As most other result objects, namely the ones used by the ORM, are proxying a :class:`_engine.CursorResult` in any case, this allows the underlying cursor result to be closed from the outside facade for the case when the ORM query is using the ``yield_per`` execution option where it does not immediately exhaust and autoclose the database cursor. TrN)rrAs rCr Result.closes( d#rFc[5er?rHrAs rC _soft_closedResult._soft_closeds !##rFc[5e)z[return ``True`` if this :class:`_engine.Result` reports .closed .. versionadded:: 1.4.43 rHrAs rCclosed Result.closed "##rFcXlU$)aConfigure the row-fetching strategy to fetch ``num`` rows at a time. This impacts the underlying behavior of the result when iterating over the result object, or otherwise making use of methods such as :meth:`_engine.Result.fetchone` that return one row at a time. Data from the underlying cursor or other data source will be buffered up to this many rows in memory, and the buffered collection will then be yielded out one row at a time or as many rows are requested. Each time the buffer clears, it will be refreshed to this many rows or as many rows remain if fewer remain. The :meth:`_engine.Result.yield_per` method is generally used in conjunction with the :paramref:`_engine.Connection.execution_options.stream_results` execution option, which will allow the database dialect in use to make use of a server side cursor, if the DBAPI supports a specific "server side cursor" mode separate from its default mode of operation. .. tip:: Consider using the :paramref:`_engine.Connection.execution_options.yield_per` execution option, which will simultaneously set :paramref:`_engine.Connection.execution_options.stream_results` to ensure the use of server side cursors, as well as automatically invoke the :meth:`_engine.Result.yield_per` method to establish a fixed row buffer size at once. The :paramref:`_engine.Connection.execution_options.yield_per` execution option is available for ORM operations, with :class:`_orm.Session`-oriented use described at :ref:`orm_queryguide_yield_per`. The Core-only version which works with :class:`_engine.Connection` is new as of SQLAlchemy 1.4.40. .. versionadded:: 1.4 :param num: number of rows to fetch each time the buffer is refilled. If set to a value below 1, fetches all rows for the next buffer. .. seealso:: :ref:`engine_stream_results` - describes Core behavior for :meth:`_engine.Result.yield_per` :ref:`orm_queryguide_yield_per` - in the :ref:`queryguide_toplevel` )rhrBrjs rC yield_perResult.yield_persb rFc([5U4UlU$)a-Apply unique filtering to the objects returned by this :class:`_engine.Result`. When this filter is applied with no arguments, the rows or objects returned will filtered such that each row is returned uniquely. The algorithm used to determine this uniqueness is by default the Python hashing identity of the whole tuple. In some cases a specialized per-entity hashing scheme may be used, such as when using the ORM, a scheme is applied which works against the primary key identity of returned objects. The unique filter is applied **after all other filters**, which means if the columns returned have been refined using a method such as the :meth:`_engine.Result.columns` or :meth:`_engine.Result.scalars` method, the uniquing is applied to **only the column or columns returned**. This occurs regardless of the order in which these methods have been called upon the :class:`_engine.Result` object. The unique filter also changes the calculus used for methods like :meth:`_engine.Result.fetchmany` and :meth:`_engine.Result.partitions`. When using :meth:`_engine.Result.unique`, these methods will continue to yield the number of rows or objects requested, after uniquing has been applied. However, this necessarily impacts the buffering behavior of the underlying cursor or datasource, such that multiple underlying calls to ``cursor.fetchmany()`` may be necessary in order to accumulate enough objects in order to provide a unique collection of the requested size. :param strategy: a callable that will be applied to rows or objects being iterated, which should return an object that represents the unique value of the row. A Python ``set()`` is used to store these identities. If not passed, a default uniqueness strategy is used which may have been assembled by the source of this :class:`_engine.Result` object. setrrBr?s rCunique Result.uniquesL&)UH$5! rFc$URU5$)aEstablish the columns that should be returned in each row. This method may be used to limit the columns returned as well as to reorder them. The given list of expressions are normally a series of integers or string key names. They may also be appropriate :class:`.ColumnElement` objects which correspond to a given statement construct. .. versionchanged:: 2.0 Due to a bug in 1.4, the :meth:`_engine.Result.columns` method had an incorrect behavior where calling upon the method with just one index would cause the :class:`_engine.Result` object to yield scalar values rather than :class:`_engine.Row` objects. In version 2.0, this behavior has been corrected such that calling upon :meth:`_engine.Result.columns` with a single index will produce a :class:`_engine.Result` object that continues to yield :class:`_engine.Row` objects, which include only a single column. E.g.:: statement = select(table.c.x, table.c.y, table.c.z) result = connection.execute(statement) for z, y in result.columns("z", "y"): ... Example of using the column objects from the statement itself:: for z, y in result.columns( statement.selected_columns.c.z, statement.selected_columns.c.y ): ... .. versionadded:: 1.4 :param \*col_expressions: indicates columns to be returned. Elements may be integer row indexes, string column names, or appropriate :class:`.ColumnElement` objects corresponding to a select construct. :return: this :class:`_engine.Result` object with the modifications given. rrBcol_expressionss rCcolumnsResult.columns<sZ""?33rFcgr?r/rAs rCscalarsResult.scalarsks>ArFcgr?r/rBrrs rCrrnrFcgr?r/rs rCrrssFIrFc[X5$)aReturn a :class:`_engine.ScalarResult` filtering object which will return single elements rather than :class:`_row.Row` objects. E.g.:: >>> result = conn.execute(text("select int_id from table")) >>> result.scalars().all() [1, 2, 3] When results are fetched from the :class:`_engine.ScalarResult` filtering object, the single column-row that would be returned by the :class:`_engine.Result` is instead returned as the column's value. .. versionadded:: 1.4 :param index: integer or row key indicating the column to be fetched from each row, defaults to ``0`` indicating the first column. :return: a new :class:`_engine.ScalarResult` filtering object referring to this :class:`_engine.Result` object. ) ScalarResultrs rCrrvs.D((rFcpUR(a [S5eURRX5$)zQreturn a callable that will retrieve the given key from a :class:`_engine.Row`. .can't use this function in 'only scalars' mode)r rIr rsras rCrsResult._getters4  ( (%@ ~~%%c44rFcpUR(a [S5eURRU5$)zRreturn a callable that will retrieve the given keys from a :class:`_engine.Row`. r)r rIr rwrfs rC _tuple_getterResult._tuple_getters4  ( (%@ ~~22488rFc[U5$)asApply a mappings filter to returned rows, returning an instance of :class:`_engine.MappingResult`. When this filter is applied, fetching rows will return :class:`_engine.RowMapping` objects instead of :class:`_engine.Row` objects. .. versionadded:: 1.4 :return: a new :class:`_engine.MappingResult` filtering object referring to this :class:`_engine.Result` object. ) MappingResultrAs rCmappingsResult.mappingssT""rFcU$)zApply a "typed tuple" typing filter to returned rows. The :attr:`_engine.Result.t` attribute is a synonym for calling the :meth:`_engine.Result.tuples` method. .. versionadded:: 2.0 r/rAs rCtResult.ts  rFcU$)aApply a "typed tuple" typing filter to returned rows. This method returns the same :class:`_engine.Result` object at runtime, however annotates as returning a :class:`_engine.TupleResult` object that will indicate to :pep:`484` typing tools that plain typed ``Tuple`` instances are returned rather than rows. This allows tuple unpacking and ``__getitem__`` access of :class:`_engine.Row` objects to by typed, for those cases where the statement invoked itself included typing information. .. versionadded:: 2.0 :return: the :class:`_engine.TupleResult` type at typing time. .. seealso:: :attr:`_engine.Result.t` - shorter synonym :attr:`_engine.Row._t` - :class:`_engine.Row` version r/rAs rCtuples Result.tupless 0 rFc[5e)zReturn a safe iterator that yields raw row data. This is used by the :meth:`_engine.Result.merge` method to merge multiple compatible results together. rHrAs rC_raw_row_iteratorResult._raw_row_iteratorrrFc"UR5$r?rrAs rCrResult.__iter__  rFc"UR5$r?rrAs rC__next__Result.__next__rrFc#R# URnU"X5nU(aUv OgM7f)aIterate through sub-lists of rows of the size given. Each list will be of the size given, excluding the last list to be yielded, which may have a small number of rows. No empty lists will be yielded. The result object is automatically closed when the iterator is fully consumed. Note that the backend driver will usually buffer the entire result ahead of time unless the :paramref:`.Connection.execution_options.stream_results` execution option is used indicating that the driver should not pre-buffer results, if possible. Not all drivers support this option and the option is silently ignored for those who do not. When using the ORM, the :meth:`_engine.Result.partitions` method is typically more effective from a memory perspective when it is combined with use of the :ref:`yield_per execution option `, which instructs both the DBAPI driver to use server side cursors, if available, as well as instructs the ORM loading internals to only build a certain amount of ORM objects from a result at a time before yielding them out. .. versionadded:: 1.4 :param size: indicate the maximum number of rows to be present in each list yielded. If None, makes use of the value set by the :meth:`_engine.Result.yield_per`, method, if it were called, or the :paramref:`_engine.Connection.execution_options.yield_per` execution option, which is equivalent in this regard. If yield_per weren't set, it makes use of the :meth:`_engine.Result.fetchmany` default, which may be backend specific and not well defined. :return: iterator of lists .. seealso:: :ref:`engine_stream_results` :ref:`orm_queryguide_yield_per` - in the :ref:`queryguide_toplevel` NrsrBrgetter partitions rC partitionsResult.partitionss0b%%t*I %'c"UR5$)z4A synonym for the :meth:`_engine.Result.all` method.rRrAs rCfetchallResult.fetchall'}}rFc<URU5nU[LagU$)aFetch one row. When all rows are exhausted, returns None. This method is provided for backwards compatibility with SQLAlchemy 1.x.x. To fetch the first row of a result only, use the :meth:`_engine.Result.first` method. To iterate through all rows, iterate the :class:`_engine.Result` object directly. :return: a :class:`_engine.Row` object if no filters are applied, or ``None`` if no rows remain. Nr[rrs rCfetchoneResult.fetchone,s# !!$' '>JrFc$URX5$)aNFetch many rows. When all rows are exhausted, returns an empty sequence. This method is provided for backwards compatibility with SQLAlchemy 1.x.x. To fetch rows in groups, use the :meth:`_engine.Result.partitions` method. :return: a sequence of :class:`_engine.Row` objects. .. seealso:: :meth:`_engine.Result.partitions` rrs rC fetchmanyResult.fetchmanyBs&##D//rFc"UR5$)aNReturn all rows in a sequence. Closes the result set after invocation. Subsequent invocations will return an empty sequence. .. versionadded:: 1.4 :return: a sequence of :class:`_engine.Row` objects. .. seealso:: :ref:`engine_stream_results` - How to stream a large result set without loading it completely in python. rrAs rCall Result.allWs"}}rFc$URSSSS9$)aFetch the first row or ``None`` if no row is present. Closes the result set and discards remaining rows. .. note:: This method returns one **row**, e.g. tuple, by default. To return exactly one single scalar value, that is, the first column of the first row, use the :meth:`_engine.Result.scalar` method, or combine :meth:`_engine.Result.scalars` and :meth:`_engine.Result.first`. Additionally, in contrast to the behavior of the legacy ORM :meth:`_orm.Query.first` method, **no limit is applied** to the SQL query which was invoked to produce this :class:`_engine.Result`; for a DBAPI driver that buffers results in memory before yielding rows, all rows will be sent to the Python process and all but the first row will be discarded. .. seealso:: :ref:`migration_20_unify_select` :return: a :class:`_engine.Row` object, or None if no rows remain. .. seealso:: :meth:`_engine.Result.scalar` :meth:`_engine.Result.one` FrwrxryrzrAs rCfirst Result.firstjs$F!!!&uU"  rFc$URSSSS9$)aReturn at most one result or raise an exception. Returns ``None`` if the result has no rows. Raises :class:`.MultipleResultsFound` if multiple rows are returned. .. versionadded:: 1.4 :return: The first :class:`_engine.Row` or ``None`` if no row is available. :raises: :class:`.MultipleResultsFound` .. seealso:: :meth:`_engine.Result.first` :meth:`_engine.Result.one` TFrrrAs rC one_or_noneResult.one_or_nones#*!!!%eE"  rFcgr?r/rAs rC scalar_oneResult.scalar_one36rFcgr?r/rAs rCrr!$rFc$URSSSS9$)zReturn exactly one scalar result or raise an exception. This is equivalent to calling :meth:`_engine.Result.scalars` and then :meth:`_engine.ScalarResult.one`. .. seealso:: :meth:`_engine.ScalarResult.one` :meth:`_engine.Result.scalars` TrrrAs rCrrs#!!!%d4"  rFcgr?r/rAs rCscalar_one_or_noneResult.scalar_one_or_nonesEHrFcgr?r/rAs rCrrrrFc$URSSSS9$)aReturn exactly one scalar result or ``None``. This is equivalent to calling :meth:`_engine.Result.scalars` and then :meth:`_engine.ScalarResult.one_or_none`. .. seealso:: :meth:`_engine.ScalarResult.one_or_none` :meth:`_engine.Result.scalars` TFrrrAs rCrrs#!!!%eD"  rFc$URSSSS9$)aReturn exactly one row or raise an exception. Raises :class:`_exc.NoResultFound` if the result returns no rows, or :class:`_exc.MultipleResultsFound` if multiple rows would be returned. .. note:: This method returns one **row**, e.g. tuple, by default. To return exactly one single scalar value, that is, the first column of the first row, use the :meth:`_engine.Result.scalar_one` method, or combine :meth:`_engine.Result.scalars` and :meth:`_engine.Result.one`. .. versionadded:: 1.4 :return: The first :class:`_engine.Row`. :raises: :class:`.MultipleResultsFound`, :class:`.NoResultFound` .. seealso:: :meth:`_engine.Result.first` :meth:`_engine.Result.one_or_none` :meth:`_engine.Result.scalar_one` TFrrrAs rCone Result.ones#:!!!%d5"  rFcgr?r/rAs rCry Result.scalars9rFrc\rSrSr%SrSrS\S'S\S'SSjrSS jr\ SS j5r SSS jjr \ SS j5r \ SS j5rSSjr\ SSj5rSSjrSSSjjrS SjrS!S"SjjrSrg)# FilterResulti9aFA wrapper for a :class:`_engine.Result` that returns objects other than :class:`_engine.Row` objects, such as dictionaries or scalar objects. :class:`_engine.FilterResult` is the common base for additional result APIs including :class:`_engine.MappingResult`, :class:`_engine.ScalarResult` and :class:`_engine.AsyncResult`. )rr r rrrr r"rcU$r?r/rAs rCrFilterResult.__enter__OrrFc<URRXU5 gr?)rrrs rCrFilterResult.__exit__Rs ""5;rFcFURRU5UlU$)a7Configure the row-fetching strategy to fetch ``num`` rows at a time. The :meth:`_engine.FilterResult.yield_per` method is a pass through to the :meth:`_engine.Result.yield_per` method. See that method's documentation for usage notes. .. versionadded:: 1.4.40 - added :meth:`_engine.FilterResult.yield_per` so that the method is available on all result set implementations .. seealso:: :ref:`engine_stream_results` - describes Core behavior for :meth:`_engine.Result.yield_per` :ref:`orm_queryguide_yield_per` - in the :ref:`queryguide_toplevel` )rrrs rCrFilterResult.yield_perUs"&!--77< rFc6URRUS9 gNr)rrrs rCrFilterResult._soft_closeks %%4%0rFc.URR$r?)rrrAs rCrFilterResult._soft_closedns  ---rFc.URR$)zdReturn ``True`` if the underlying :class:`_engine.Result` reports closed .. versionadded:: 1.4.43 )rrrAs rCrFilterResult.closedrs  '''rFc8URR5 g)zEClose this :class:`_engine.FilterResult`. .. versionadded:: 1.4.43 N)rrrAs rCrFilterResult.close|s !rFc.URR$r?)rrrAs rCrFilterResult._attributess  ,,,rFc6URR5$r?)rr rAs rCr FilterResult._fetchiter_impls  0022rFc4URRUS9$)Nr)rrrs rCrFilterResult._fetchone_impls  //:/FFrFc6URR5$r?)rrrAs rCrFilterResult._fetchall_impls  //11rFNc4URRUS9$Nr)rrrs rCrFilterResult._fetchmany_impls  00d0;;rF)rr1r2r5rrr4r3)rzDict[Any, Any]rrrr?r)rrrrrrrrrrrrrrrrrr rrrrr/rFrCrCrC9sI<;<*1..(("--3"'GG ,G 2%)<!< (<+>q+AD ($/$D$D!rFNc([5U4UlU$)zApply unique filtering to the objects returned by this :class:`_engine.ScalarResult`. See :meth:`_engine.Result.unique` for usage details. rrs rCrScalarResult.unique&)UH$5! rFc#R# URnU"X5nU(aUv OgM7f)zIterate through sub-lists of elements of the size given. Equivalent to :meth:`_engine.Result.partitions` except that scalar values, rather than :class:`_engine.Row` objects, are returned. Nrrs rCrScalarResult.partitionss/%%t*I rc"UR5$):A synonym for the :meth:`_engine.ScalarResult.all` method.rrAs rCrScalarResult.fetchallrrFc$URX5$)zFetch many objects. Equivalent to :meth:`_engine.Result.fetchmany` except that scalar values, rather than :class:`_engine.Row` objects, are returned. rrs rCrScalarResult.fetchmanys##D//rFc"UR5$)zReturn all scalar values in a sequence. Equivalent to :meth:`_engine.Result.all` except that scalar values, rather than :class:`_engine.Row` objects, are returned. rrAs rCr ScalarResult.alls}}rFc"UR5$r?rrAs rCrScalarResult.__iter__rrFc"UR5$r?rrAs rCrScalarResult.__next__rrFc$URSSSS9$)zFetch the first object or ``None`` if no object is present. Equivalent to :meth:`_engine.Result.first` except that scalar values, rather than :class:`_engine.Row` objects, are returned. FrrrAs rCrScalarResult.first#!!!&uU"  rFc$URSSSS9$)zReturn at most one object or raise an exception. Equivalent to :meth:`_engine.Result.one_or_none` except that scalar values, rather than :class:`_engine.Row` objects, are returned. TFrrrAs rCrScalarResult.one_or_none#!!!%eE"  rFc$URSSSS9$)zReturn exactly one object or raise an exception. Equivalent to :meth:`_engine.Result.one` except that scalar values, rather than :class:`_engine.Row` objects, are returned. TFrrrAs rCr"ScalarResult.one#!!!%d5"  rF)r r rr)r4r"rrrr?r6rrrzIterator[Sequence[_R]]r Sequence[_R]rrrr}rrrr)rrrrrrrrrrrrrr rrrrr"rr/rFrCrrsQ IN;; E$ 0!!      rFrcB\rSrSrSrSr\(aSSSjjrSSjrSSjr SSSjjr SS jr SS jr SS jr SS jrSS jrSSjr\SSj5r\S Sj5rS Sjr\S!Sj5r\S"Sj5rS"Sjr\S!Sj5r\S Sj5rS SjrSrgSrg)# TupleResultizA :class:`_engine.Result` that's typed as returning plain Python tuples instead of rows. Since :class:`_engine.Row` acts like a tuple in every way already, this class is a typing only class, regular :class:`_engine.Result` is still used at runtime. r/Ncg)zIterate through sub-lists of elements of the size given. Equivalent to :meth:`_engine.Result.partitions` except that tuple values, rather than :class:`_engine.Row` objects, are returned. Nr/rs rCrTupleResult.partitions*s rFcg)zFetch one tuple. Equivalent to :meth:`_engine.Result.fetchone` except that tuple values, rather than :class:`_engine.Row` objects, are returned. Nr/rAs rCrTupleResult.fetchone6 rFcg)rhNr/rAs rCrTupleResult.fetchall@s rFcg)zFetch many objects. Equivalent to :meth:`_engine.Result.fetchmany` except that tuple values, rather than :class:`_engine.Row` objects, are returned. Nr/rs rCrTupleResult.fetchmanyDrrFcg)zReturn all scalar values in a sequence. Equivalent to :meth:`_engine.Result.all` except that tuple values, rather than :class:`_engine.Row` objects, are returned. Nr/rAs rCr TupleResult.allNrrFcgr?r/rAs rCrTupleResult.__iter__XsCrFcgr?r/rAs rCrTupleResult.__next__Zs#rFcg)zFetch the first object or ``None`` if no object is present. Equivalent to :meth:`_engine.Result.first` except that tuple values, rather than :class:`_engine.Row` objects, are returned. Nr/rAs rCrTupleResult.first\s rFcg)zReturn at most one object or raise an exception. Equivalent to :meth:`_engine.Result.one_or_none` except that tuple values, rather than :class:`_engine.Row` objects, are returned. Nr/rAs rCrTupleResult.one_or_nonegrrFcg)zReturn exactly one object or raise an exception. Equivalent to :meth:`_engine.Result.one` except that tuple values, rather than :class:`_engine.Row` objects, are returned. Nr/rAs rCr"TupleResult.oneqrrFcgr?r/rAs rCrTupleResult.scalar_one{s)rrrrrrrrrrrr rrrrr"rrrryrr/rFrCrrsI)- %  #      0%    ? ? ( (   (      : :  E E $ $ KrFrc\rSrSrSrSrSr\R"S5r SSjr SSSjjr SS jr SSS jjr SS jrSS jrSSS jjrSSjrSSjrSSjrSSjrSSjrSSjrSrg)rizA wrapper for a :class:`_engine.Result` that returns dictionary values rather than :class:`_engine.Row` values. The :class:`_engine.MappingResult` object is acquired by calling the :meth:`_engine.Result.mappings` method. r/T_mappingcXlURUlURUlUR(a"URR S/5Ulggr)rrr r rmrBresults rCrMappingResult.__init__sI"$*$?$?!))  * *!^^33QC8DN +rFNc([5U4UlU$)zApply unique filtering to the objects returned by this :class:`_engine.MappingResult`. See :meth:`_engine.Result.unique` for usage details. rrs rCrMappingResult.uniquerdrFc$URU5$)z:Establish the columns that should be returned in each row.rrs rCrMappingResult.columnss""?33rFc#R# URnU"X5nU(aUv OgM7f)zIterate through sub-lists of elements of the size given. Equivalent to :meth:`_engine.Result.partitions` except that :class:`_engine.RowMapping` values, rather than :class:`_engine.Row` objects, are returned. Nrrs rCrMappingResult.partitionss/%%t*I rc"UR5$)z;A synonym for the :meth:`_engine.MappingResult.all` method.rrAs rCrMappingResult.fetchallrrFc<URU5nU[LagU$)zFetch one object. Equivalent to :meth:`_engine.Result.fetchone` except that :class:`_engine.RowMapping` values, rather than :class:`_engine.Row` objects, are returned. Nrrs rCrMappingResult.fetchones#!!$' '>JrFc$URX5$)zFetch many objects. Equivalent to :meth:`_engine.Result.fetchmany` except that :class:`_engine.RowMapping` values, rather than :class:`_engine.Row` objects, are returned. rrs rCrMappingResult.fetchmany s##D//rFc"UR5$)zReturn all scalar values in a sequence. Equivalent to :meth:`_engine.Result.all` except that :class:`_engine.RowMapping` values, rather than :class:`_engine.Row` objects, are returned. rrAs rCr MappingResult.alls}}rFc"UR5$r?rrAs rCrMappingResult.__iter__!rrFc"UR5$r?rrAs rCrMappingResult.__next__$rrFc$URSSSS9$)zFetch the first object or ``None`` if no object is present. Equivalent to :meth:`_engine.Result.first` except that :class:`_engine.RowMapping` values, rather than :class:`_engine.Row` objects, are returned. FrrrAs rCrMappingResult.first'rtrFc$URSSSS9$)zReturn at most one object or raise an exception. Equivalent to :meth:`_engine.Result.one_or_none` except that :class:`_engine.RowMapping` values, rather than :class:`_engine.Row` objects, are returned. TFrrrAs rCrMappingResult.one_or_none4rwrFc$URSSSS9$)zReturn exactly one object or raise an exception. Equivalent to :meth:`_engine.Result.one` except that :class:`_engine.RowMapping` values, rather than :class:`_engine.Row` objects, are returned. TFrrrAs rCr"MappingResult.one@rzrF)r rr)rr"r?r6r7)rrrzIterator[Sequence[RowMapping]])rSequence[RowMapping])rzOptional[RowMapping])rrrr)rzIterator[RowMapping])rr)rrrrrrrrp attrgetterr rrrrrrrr rrrrr"rr/rFrCrrszIN&11*=94 %)! '(  0 !!      rFrcT\rSrSr%SrS\S'S SjrS SjrS SjrSSjr S r g )r)iMaRepresents a :class:`_engine.Result` object in a "frozen" state suitable for caching. The :class:`_engine.FrozenResult` object is returned from the :meth:`_engine.Result.freeze` method of any :class:`_engine.Result` object. A new iterable :class:`_engine.Result` object is generated from a fixed set of data each time the :class:`_engine.FrozenResult` is invoked as a callable:: result = connection.execute(query) frozen = result.freeze() unfrozen_result_one = frozen() for row in unfrozen_result_one: print(row) unfrozen_result_two = frozen() rows = unfrozen_result_two.all() # ... etc .. versionadded:: 1.4 .. seealso:: :ref:`do_orm_execute_re_executing` - example usage within the ORM to implement a result-set cache. :func:`_orm.loading.merge_frozen_result` - ORM function to merge a frozen result back into a :class:`_orm.Session`. rdatacURR5UlURUlURUlUR(a[ UR 55UlgUR5Ulgr?) r rPr$r rrrrrrs rCrFrozenResult.__init__vs`((446 (.(G(G%!--  ( (V5578DI)DIrFcUR(aURVs/sHo/PM sn$URVs/sHn[U5PM sn$s snfs snfr?)r rr)rBelemr,s rC rewrite_rowsFrozenResult.rewrite_rowssI  ( ('+yy1ytFy1 1)-3#DI3 323s AAc[R[5nURUlURUlURUlUR(aUVs/sHo3SPM snUlU$XlU$s snfr)r)__new__r$rr r)rB tuple_datafrds rC with_new_rowsFrozenResult.with_new_rowsss ! !, /mm ))&*&C&C#  ( (%/0ZtZ0BG !G 1s"Bc[UR[UR55nURUlUR UlU$r?)IteratorResultr$rrrr rs rC__call__FrozenResult.__call__s@&4 MM4 ?' "--*.*G*G' rF)rr rr$N)r Result[_TP])rzSequence[Sequence[Any]])rr;rr@)rr) rrrrrrrrrrrr/rFrCr)r)Ms4$L *4 ,   rFr)c\rSrSrSrSrSrSSSjjr\SSj5r SSSjjr SSjr SS jr SS jr SSS jjrSS jrSSS jjrSrg)rizA :class:`_engine.Result` that gets data from a Python iterator of :class:`_engine.Row` objects or similar row-like data. .. versionadded:: 1.4 FNc4XlX lX0lX@lgr?)r iteratorrawr )rBrrrr s rCrIteratorResult.__init__s) (@%rFcUR$)zcReturn ``True`` if this :class:`_engine.IteratorResult` has been closed .. versionadded:: 1.4.43 ) _hard_closedrAs rCrIteratorResult.closeds   rFc U(aSUlURbURR"SSU0UD6 [/5UlUR 5 SUlg)NTrr/)rrrrr_reset_memoizationsr)rBrkws rCrIteratorResult._soft_closesP  $D  88  HH 1d 1b 1R    " rFc.[R"S5e)NzThis result object is closed.)rResourceClosedErrorrAs rC_raise_hard_closed!IteratorResult._raise_hard_closeds%%&EFFrFcUR$r?)rrAs rCr IteratorResult._raw_row_iterators }}rFc\UR(aUR5 UR$r?)rrrrAs rCr IteratorResult._fetchiter_impls!     # # %}}rFcUR(aUR5 [UR[5nU[LaUR US9 gU$rK)rrnextrrr)rBrr,s rCrIteratorResult._fetchone_implsI     # # %4=='* '>   *  -JrFcUR(aUR5 [UR5UR 5 $!UR 5 f=fr?)rrrrrrAs rCrIteratorResult._fetchall_implsA     # # %  &    D   s AAcUR(aUR5 [[R"UR SU55$r)rrr itertoolsislicerrs rCrIteratorResult._fetchmany_impls7     # # %I$$T]]At<==rF)rr rr rrr)rr-r(Iterator[_InterimSupportsScalarsRowType]rrr rr4rrrrrrr)rrr:)rrrrr?r)rrrrrrrrrrrrrr rrrrr/rFrCrrsLL &*). A' A; A# A #' A!!!G "'   , %)>!> (>>rFrc>[[/5[/55$r?)rrrr/rFrC null_resultrs .r2DH ==rFc^\rSrSrSrSS Sjjr\S Sj5rS S U4SjjjrS SU4Sjjjr Sr U=r $)ChunkedIteratorResultiaAn :class:`_engine.IteratorResult` that works from an iterator-producing callable. The given ``chunks`` argument is a function that is given a number of rows to return in each chunk, or ``None`` for all rows. The function should then return an un-consumed iterator of lists, each list of the requested size. The function can be called at any time again, in which case it should continue from the same result set but adjust the chunk size as given. .. versionadded:: 1.4 cXlX lX0lX@l[R R URS55UlXPlgr?) r chunksr rrchain from_iterablerdynamic_yield_per)rBrrsource_supports_scalarsrrs rCrChunkedIteratorResult.__init__ s>) (?%!55dkk$6GH !2rFcxXl[RRUR U55UlU$r?)rhrrrrrrs rCrChunkedIteratorResult.yield_per s-!55dkk#6FG  rFc :>[TU]"SSU0UD6 SUlg)Nrc/$r?r/r]s rC3ChunkedIteratorResult._soft_close..# s2rFr/)superrr)rBrrrs rCr!ChunkedIteratorResult._soft_close! s ,,,% rFc>UR(a3[RRUR U55Ul[ TU]US9$r\)rrrrrrr r)rBrrs rCr%ChunkedIteratorResult._fetchmany_impl% s@  ! !%OO99$++d:KLDMw&D&11rF)r r rhrrrr)FNF) rr-rzBCallable[[Optional[int]], Iterator[Sequence[_InterimRowType[_R]]]]rrrrrrr5rrr?r) rrrrrrrrrrr __classcell__rs@rCrrs *).%)"'3'3 3 "& 3#3 3"  && %)2!2 (22rFrcV^\rSrSr%SrSrS\S'S U4SjjrS S SjjrSr U=r $) r-i- zA :class:`_engine.Result` that is merged from any number of :class:`_engine.Result` objects. Returned by the :meth:`_engine.Result.merge` method. .. versionadded:: 1.4 Frrowcountcl>X l[TU] U[RR SU555 USR UlUSRUlUSRUlURR"UVs/sHo3RPM sn6Ul gs snf)Nc3@# UHoR5v M g7fr?)r)r`rs rCra(MergedResult.__init__..@ s*/6!##%%wsr) _resultsr rrrrrrhr r merge_with)rBrresultsrrs rCrMergedResult.__init__: s    OO ) )*/6*  %,AJ$C$C!!!*//)0 (K(K%++66%, -WmmW -  -sB1c pURHnUR"SSU0UD6 M U(aSUlgg)NrTr/)rrr)rBrrrs rCrMergedResult._soft_closeO s3A MM *t *r * DK rF)rrr rrhr)rr-rzSequence[Result[_TP]]rr) rrrrrrrrrrr rs@rCr-r-- s4F - 8M *rFr-r?)rr8rr?rz#Callable[[Iterable[Any]], Row[Any]])rzIteratorResult[Any])Xr __future__renumrrrrptypingrrrrr r r r r rrrrrrrrrr,rrrrsql.baserrrr r! util._has_cyr" util.typingr#r$_py_rowr%"sqlalchemy.cyextension.resultproxy sql.elementsr& sql.type_apir'r_KeyTyperrrr6_RowData _RawRowTyper(r*r+_InterimRowType_InterimSupportsScalarsRowType_ProcessorsTyper_UniqueFilterTyperr-KeysViewr@rrrrrrrrCr TypingOnlyrrr)rrrr-r/rFrCr/s,"  ""(4*! 3M 03 .. /hm$ h./  S:s* +CHo ; T" T e5c?+K( "'s3x}!58$?@AXc]OXc]:;cUCZ(s3x2C)DDEu$u$p)$)DK>K^37 "/(T ..Z!& Z!z##4g >Ys3x0g >T]<>"%]<@@ <#@ F`,r"DOO`FK I|J7K \M73<M`P>VC[P>f>62N3/62r&>#&&rF