Index | index by Group | index by Distribution | index by Vendor | index by creation date | index by Name | Mirrors | Help | Search |
Name: python310-SQLAlchemy | Distribution: openSUSE Tumbleweed |
Version: 2.0.36 | Vendor: openSUSE |
Release: 1.1 | Build date: Wed Nov 6 15:43:11 2024 |
Group: Unspecified | Build host: reproducible |
Size: 19546825 | Source RPM: python-SQLAlchemy-2.0.36-1.1.src.rpm |
Packager: http://bugs.opensuse.org | |
Url: https://www.sqlalchemy.org | |
Summary: Database Abstraction Library |
SQLAlchemy is an Object Relational Mappper (ORM) that provides a flexible, high-level interface to SQL databases. Database and domain concepts are decoupled, allowing both sides maximum flexibility and power. SQLAlchemy provides a powerful mapping layer that can work as automatically or as manually as you choose, determining relationships based on foreign keys or letting you define the join conditions explicitly, to bridge the gap between database and domain.
MIT
* Wed Nov 06 2024 John Paul Adrian Glaubitz <adrian.glaubitz@suse.com> - Update to 2.0.36 * Fixed bug where SQL functions passed to :paramref:`_schema.Column.server_default` would not be rendered with the particular form of parenthesization now required by newer versions of MySQL and MariaDB. Pull request courtesy of huuya. * Fixed bug in ORM bulk update/delete where using RETURNING with bulk update/delete in combination with ``populate_existing`` would fail to accommodate the ``populate_existing`` option. * Continuing from :ticket:`11912`, columns marked with :paramref:`.mapped_column.onupdate`, :paramref:`.mapped_column.server_onupdate`, or :class:`.Computed` are now refreshed in ORM instances when running an ORM enabled UPDATE with WHERE criteria, even if the statement does not use RETURNING or ``populate_existing``. * Added new parameter :paramref:`_orm.mapped_column.hash` to ORM constructs such as :meth:`_orm.mapped_column`, :meth:`_orm.relationship`, etc., which is interpreted for ORM Native Dataclasses in the same way as other dataclass-specific field parameters. * Fixed bug in reflection of table comments where unrelated text would be returned if an entry in the ``pg_description`` table happened to share the same oid (objoid) as the table being reflected. * Fixed regression caused by fixes to joined eager loading in :ticket:`11449` released in 2.0.31, where a particular joinedload case could not be asserted correctly. We now have an example of that case so the assertion has been repaired to allow for it. * Improved the error message emitted when trying to map as dataclass a class while also manually providing the ``__table__`` attribute. This usage is currently not supported. * Improved a query used for the MySQL 8 backend when reflecting foreign keys to be better optimized. Previously, for a database that had millions of columns across all tables, the query could be prohibitively slow; the query has been reworked to take better advantage of existing indexes. * Datatypes that are binary based such as :class:`.VARBINARY` will resolve to :class:`.LargeBinary` when the :meth:`.TypeEngine.as_generic()` method is called. * The :class:`.postgresql.JSON` and :class:`.postgresql.JSONB` datatypes will now render a "bind cast" in all cases for all PostgreSQL backends, including psycopg2, whereas previously it was only enabled for some backends. This allows greater accuracy in allowing the database server to recognize when a string value is to be interpreted as JSON. * Refined the check which the ORM lazy loader uses to detect "this would be loading by primary key and the primary key is NULL, skip loading" to take into account the current setting for the :paramref:`.orm.Mapper.allow_partial_pks` parameter. If this parameter is ``False``, then a composite PK value that has partial NULL elements should also be skipped. This can apply to some composite overlapping foreign key configurations. * Fixed bug in ORM "update with WHERE clause" feature where an explicit ``.returning()`` would interfere with the "fetch" synchronize strategy due to an assumption that the ORM mapped class featured the primary key columns in a specific position within the RETURNING. This has been fixed to use appropriate ORM column targeting. * Fixed regression from 1.4 where some datatypes such as those derived from :class:`.TypeDecorator` could not be pickled when they were part of a larger SQL expression composition due to internal supporting structures themselves not being pickleable. - Adjust upstream source name in spec file - For changes between 2.0.33 through 2.0.34 see the upstream changelog * https://docs.sqlalchemy.org/en/20/changelog * Mon Aug 19 2024 Dirk Müller <dmueller@suse.com> - update to 2.0.32: * https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.32 * Wed Jun 19 2024 Adrian Schröter <adrian@suse.de> - update to 2.0.31 * https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.31 - Python 3.13 support * Thu Mar 07 2024 Adrian Schröter <adrian@suse.de> - update to 2.0.28: * https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.28 * Sun Jan 21 2024 Dirk Müller <dmueller@suse.com> - update to 2.0.25: * preliminary support for Python 3.12 pep-695 type alias structures * see https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.25 * Fri Dec 29 2023 Dirk Müller <dmueller@suse.com> - update to 2.0.24: * https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.24 * Mon Nov 27 2023 Dirk Müller <dmueller@suse.com> - update to 2.0.23: * https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.23 * https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.22 * Fri Sep 29 2023 Martin Schreiner <martin.schreiner@suse.com> - Update to 2.0.21: * Changes from 2.0.21: https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.21 * Changes from 2.0.20: https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.20 - Remove .gitignore files from source tree, removes all rpmlint warnings. * Sun Aug 13 2023 Dirk Müller <dmueller@suse.com> - use generic Cython >= 3 buildrequires * Tue Jul 25 2023 Dirk Müller <dmueller@suse.com> - update to 2.0.19: * Various bugfixes, see https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.19 * Mon Jun 19 2023 Dirk Müller <dmueller@suse.com> - update to 2.0.16: * Python 3.12 support * Fixed regression in the 2.0 series where the default value of validates.include_backrefs got changed to False for the validates() function * Unified the custom PostgreSQL operator definitions * Added support for PostgreSQL 10 NULLS NOT DISTINCT feature of unique indexes and unique constraints * Use proper precedence on PostgreSQL specific operators, such as @> * see https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.16 * Tue May 30 2023 Daniel Garcia <daniel.garcia@suse.com> - Switch documentation to be within the main package. * Sat May 20 2023 Ben Greiner <code@bnavigator.de> - Update to 2.0.15 [#] orm * As more projects are using new-style “2.0” ORM querying, it’s becoming apparent that the conditional nature of “autoflush”, being based on whether or not the given statement refers to ORM entities, is becoming more of a key behavior. Up until now, the “ORM” flag for a statement has been loosely based around whether or not the statement returns rows that correspond to ORM entities or columns; the original purpose of the “ORM” flag was to enable ORM-entity fetching rules which apply post-processing to Core result sets as well as ORM loader strategies to the statement. For statements that don’t build on rows that contain ORM entities, the “ORM” flag was considered to be mostly unnecessary. * It still may be the case that “autoflush” would be better taking effect for all usage of Session.execute() and related methods, even for purely Core SQL constructs. However, this still could impact legacy cases where this is not expected and may be more of a 2.1 thing. For now however, the rules for the “ORM-flag” have been opened up so that a statement that includes ORM entities or attributes anywhere within, including in the WHERE / ORDER BY / GROUP BY clause alone, within scalar subqueries, etc. will enable this flag. This will cause “autoflush” to occur for such statements and also be visible via the ORMExecuteState.is_orm_statement event-level attribute. References: #9805 [#] postgresql * Repaired the base Uuid datatype for the PostgreSQL dialect to make full use of the PG-specific UUID dialect-specific datatype when “native_uuid” is selected, so that PG driver behaviors are included. This issue became apparent due to the insertmanyvalues improvement made as part of #9618, where in a similar manner as that of #9739, the asyncpg driver is very sensitive to datatype casts being present or not, and the PostgreSQL driver-specific native UUID datatype must be invoked when this generic type is used so that these casts take place. References: #9808 - Release 2.0.13 [#] orm * Modified the JoinedLoader implementation to use a simpler approach in one particular area where it previously used a cached structure that would be shared among threads. The rationale is to avoid a potential race condition which is suspected of being the cause of a particular crash that’s been reported multiple times. The cached structure in question is still ultimately “cached” via the compiled SQL cache, so a performance degradation is not anticipated. References: #9777 * Fixed regression where use of update() or delete() within a CTE construct, then used in a select(), would raise a CompileError as a result of ORM related rules for performing ORM-level update/delete statements. References: #9767 * Fixed issue in new ORM Annotated Declarative where using a ForeignKey (or other column-level constraint) inside of mapped_column() which is then copied out to models via pep-593 Annotated would apply duplicates of each constraint to the Column as produced in the target Table, leading to incorrect CREATE TABLE DDL as well as migration directives under Alembic. References: #9766 * Fixed issue where using additional relationship criteria with the joinedload() loader option, where the additional criteria itself contained correlated subqueries that referred to the joined entities and therefore also required “adaption” to aliased entities, would be excluded from this adaption, producing the wrong ON clause for the joinedload. References: #9779 [#] sql * Generalized the MSSQL try_cast() function into the sqlalchemy. import namespace so that it may be implemented by third party dialects as well. Within SQLAlchemy, the try_cast() function remains a SQL Server-only construct that will raise CompileError if used with backends that don’t support it. * try_cast() implements a CAST where un-castable conversions are returned as NULL, instead of raising an error. Theoretically, the construct could be implemented by third party dialects for Google BigQuery, DuckDB, and Snowflake, and possibly others. Pull request courtesy Nick Crews. References: #9752 * Fixed issue in values() construct where an internal compilation error would occur if the construct were used inside of a scalar subquery. References: #9772 [#] postgresql * Fixed apparently very old issue where the ENUM.create_type parameter, when set to its non-default of False, would not be propagated when the Column which it’s a part of were copied, as is common when using ORM Declarative mixins. References: #9773 [#] tests * Fixed test that relied on the sys.getsizeof() function to not run on pypy, where this function appears to have different behavior than it does on cpython. References: #9789 - PEP517 - Add missing runtime requirement * Sun May 14 2023 Dirk Müller <dmueller@suse.com> - update to 2.0.13: * https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.13 * Fri May 12 2023 Dirk Müller <dmueller@suse.com> - drop unnecessary mypy dependency * Thu May 04 2023 Dirk Müller <dmueller@suse.com> - update to SQLalchemy 2.0.x: * 1.x remains available as SQLAlchemy1 Long list of changes, see https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.12 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.11 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.10 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.9 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.8 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.7 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.6 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.5 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.4 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.3 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.2 https://docs.sqlalchemy.org/en/20/changelog/changelog_20.html#change-2.0.1 * Fri Apr 21 2023 Dirk Müller <dmueller@suse.com> - add sle15_python_module_pythons (jsc#PED-68) * Thu Apr 13 2023 Matej Cepl <mcepl@suse.com> - Make calling of %{sle15modernpython} optional. * Wed Feb 15 2023 Dirk Müller <dmueller@suse.com> - update to 1.4.46: * A new deprecation “uber warning” is now emitted at runtime the first time any SQLAlchemy 2.0 deprecation warning would normally be emitted, but the SQLALCHEMY_WARN_20 environment variable is not set. see https://docs.sqlalchemy.org/en/20/changelog/changelog_14.html#change-1.4.46 * Mon Jan 02 2023 Dirk Müller <dmueller@suse.com> - update to 1.4.45: see https://docs.sqlalchemy.org/en/20/changelog/changelog_14.html#change-1.4.45 * Sat Oct 22 2022 Arun Persaud <arun@gmx.de> - update to version 1.4.42: * orm + The Session.execute.bind_arguments dictionary is no longer mutated when passed to Session.execute() and similar; instead, it’s copied to an internal dictionary for state changes. Among other things, this fixes and issue where the “clause” passed to the Session.get_bind() method would be incorrectly referring to the Select construct used for the “fetch” synchronization strategy, when the actual query being emitted was a Delete or Update. This would interfere with recipes for “routing sessions”. References: #8614 + A warning is emitted in ORM configurations when an explicit remote() annotation is applied to columns that are local to the immediate mapped class, when the referenced class does not include any of the same table columns. Ideally this would raise an error at some point as it’s not correct from a mapping point of view. References: #7094 + A warning is emitted when attempting to configure a mapped class within an inheritance hierarchy where the mapper is not given any polymorphic identity, however there is a polymorphic discriminator column assigned. Such classes should be abstract if they never intend to load directly. References: #7545 + Fixed regression for 1.4 in contains_eager() where the “wrap in subquery” logic of joinedload() would be inadvertently triggered for use of the contains_eager() function with similar statements (e.g. those that use distinct(), limit() or offset()), which would then lead to secondary issues with queries that used some combinations of SQL label names and aliasing. This “wrapping” is not appropriate for contains_eager() which has always had the contract that the user-defined SQL statement is unmodified with the exception of adding the appropriate columns to be fetched. References: #8569 + Fixed regression where using ORM update() with synchronize_session=’fetch’ would fail due to the use of evaluators that are now used to determine the in-Python value for expressions in the the SET clause when refreshing objects; if the evaluators make use of math operators against non-numeric values such as PostgreSQL JSONB, the non-evaluable condition would fail to be detected correctly. The evaluator now limits the use of math mutation operators to numeric types only, with the exception of “+” that continues to work for strings as well. SQLAlchemy 2.0 may alter this further by fetching the SET values completely rather than using evaluation. References: [#8507] * engine + Fixed issue where mixing “*” with additional explicitly-named column expressions within the columns clause of a select() construct would cause result-column targeting to sometimes consider the label name or other non-repeated names to be an ambiguous target. References: #8536 * asyncio + Improved implementation of asyncio.shield() used in context managers as added in #8145, such that the “close” operation is enclosed within an asyncio.Task which is then strongly referenced as the operation proceeds. This is per Python documentation indicating that the task is otherwise not strongly referenced. References: #8516 * postgresql + aggregate_order_by now supports cache generation. References: [#8574] * mysql + Adjusted the regular expression used to match “CREATE VIEW” when testing for views to work more flexibly, no longer requiring the special keyword “ALGORITHM” in the middle, which was intended to be optional but was not working correctly. The change allows view reflection to work more completely on MySQL-compatible variants such as StarRocks. Pull request courtesy John Bodley. References: #8588 * mssql + Fixed yet another regression in SQL Server isolation level fetch (see #8231, #8475), this time with “Microsoft Dynamics CRM Database via Azure Active Directory”, which apparently lacks the system_views view entirely. Error catching has been extended that under no circumstances will this method ever fail, provided database connectivity is present. References: #8525 - Also remove the conditional definition of python_module. * Sat Sep 17 2022 Dirk Müller <dmueller@suse.com> - update to 1.4.41: * Fixed issue where use of the :func:`_sql.table` construct, passing a string for the :paramref:`_sql.table.schema` parameter, would fail to take the "schema" string into account when producing a cache key, thus leading to caching collisions if multiple, same-named :func:`_sql.table` constructs with different schemas were used. * Fixed event listening issue where event listeners added to a superclass would be lost if a subclass were created which then had its own listeners associated. The practical example is that of the :class:`.sessionmaker` class created after events have been associated with the :class:`_orm.Session` class. * Hardened the cache key strategy for the :func:`_orm.aliased` and :func:`_orm.with_polymorphic` constructs. While no issue involving actual statements being cached can easily be demonstrated (if at all), these two constructs were not including enough of what makes them unique in their cache keys for caching on the aliased construct alone to be accurate. * Fixed regression appearing in the 1.4 series where a joined-inheritance query placed as a subquery within an enclosing query for that same entity would fail to render the JOIN correctly for the inner query. The issue manifested in two different ways prior and subsequent to version 1.4.18 (related issue :ticket:`6595`), in one case rendering JOIN twice, in the other losing the JOIN entirely. To resolve, the conditions under which "polymorphic loading" are applied have been scaled back to not be invoked for simple joined inheritance queries. * Fixed issue in :mod:`sqlalchemy.ext.mutable` extension where collection links to the parent object would be lost if the object were merged with :meth:`.Session.merge` while also passing :paramref:`.Session.merge.load` as False. * Fixed issue involving :func:`_orm.with_loader_criteria` where a closure variable used as bound parameter value within the lambda would not carry forward correctly into additional relationship loaders such as :func:`_orm.selectinload` and :func:`_orm.lazyload` after the statement were cached, using the stale originally-cached value instead. * Fixed regression caused by the fix for :ticket:`8231` released in 1.4.40 where connection would fail if the user did not have permission to query the ``dm_exec_sessions`` or ``dm_pdw_nodes_exec_sessions`` system views when trying to determine the current transaction isolation level. * Integrated support for asyncpg's ``terminate()`` method call for cases where the connection pool is recycling a possibly timed-out connection, where a connection is being garbage collected that wasn't gracefully * Wed Aug 17 2022 Arun Persaud <arun@gmx.de> - update to version 1.4.40: * orm + [orm] [bug] Fixed issue where referencing a CTE multiple times in conjunction with a polymorphic SELECT could result in multiple “clones” of the same CTE being constructed, which would then trigger these two CTEs as duplicates. To resolve, the two CTEs are deep-compared when this occurs to ensure that they are equivalent, then are treated as equivalent. References: #8357 + [orm] [bug] A select() construct that is passed a sole ‘*’ argument for SELECT *, either via string, text(), or literal_column(), will be interpreted as a Core-level SQL statement rather than as an ORM level statement. This is so that the *, when expanded to match any number of columns, will result in all columns returned in the result. the ORM- level interpretation of select() needs to know the names and types of all ORM columns up front which can’t be achieved when '*' is used. If '* is used amongst other expressions simultaneously with an ORM statement, an error is raised as this can’t be interpreted correctly by the ORM. References: #8235 * orm declarative + [orm] [declarative] [bug] Fixed issue where a hierarchy of classes set up as an abstract or mixin declarative classes could not declare standalone columns on a superclass that would then be copied correctly to a declared_attr callable that wanted to make use of them on a descendant class. References: #8190 * engine + [engine] [usecase] Implemented new Connection.execution_options.yield_per execution option for Connection in Core, to mirror that of the same yield_per option available in the ORM. The option sets both the Connection.execution_options.stream_results option at the same time as invoking Result.yield_per(), to provide the most common streaming result configuration which also mirrors that of the ORM use case in its usage pattern. See also: Using Server Side Cursors (a.k.a. stream results) - revised documentation + [engine] [bug] Fixed bug in Result where the usage of a buffered result strategy would not be used if the dialect in use did not support an explicit “server side cursor” setting, when using Connection.execution_options.stream_results. This is in error as DBAPIs such as that of SQLite and Oracle already use a non-buffered result fetching scheme, which still benefits from usage of partial result fetching. The “buffered” strategy is now used in all cases where Connection.execution_options.stream_results is set. + [engine] [bug] Added FilterResult.yield_per() so that result implementations such as MappingResult, ScalarResult and AsyncResult have access to this method. References: #8199 * sql + [sql] [bug] Adjusted the SQL compilation for string containment functions .contains(), .startswith(), .endswith() to force the use of the string concatenation operator, rather than relying upon the overload of the addition operator, so that non-standard use of these operators with for example bytestrings still produces string concatenation operators. References: #8253 * mypy + [mypy] [bug] Fixed a crash of the mypy plugin when using a lambda as a Column default. Pull request curtesy of tchapi. References: #8196 * asyncio + [asyncio] [bug] Added asyncio.shield() to the connection and session release process specifically within the __aexit__() context manager exit, when using AsyncConnection or AsyncSession as a context manager that releases the object when the context manager is complete. This appears to help with task cancellation when using alternate concurrency libraries such as anyio, uvloop that otherwise don’t provide an async context for the connection pool to release the connection properly during task cancellation. References: #8145 * postgresql + [postgresql] [bug] Fixed issue in psycopg2 dialect where the “multiple hosts” feature implemented for #4392, where multiple host:port pairs could be passed in the query string as ?host=host1:port1&host=host2:port2&host=host3:port3 was not implemented correctly, as it did not propagate the “port” parameter appropriately. Connections that didn’t use a different “port” likely worked without issue, and connections that had “port” for some of the entries may have incorrectly passed on that hostname. The format is now corrected to pass hosts/ports appropriately. As part of this change, maintained support for another multihost style that worked unintentionally, which is comma-separated ?host=h1,h2,h3&port=p1,p2,p3. This format is more consistent with libpq’s query-string format, whereas the previous format is inspired by a different aspect of libpq’s URI format but is not quite the same thing. If the two styles are mixed together, an error is raised as this is ambiguous. References: #4392 * mssql + [mssql] [bug] Fixed issues that prevented the new usage patterns for using DML with ORM objects presented at Using INSERT, UPDATE and ON CONFLICT (i.e. upsert) to return ORM Objects from working correctly with the SQL Server pyodbc dialect. References: #8210 + [mssql] [bug] Fixed issue where the SQL Server dialect’s query for the current isolation level would fail on Azure Synapse Analytics, due to the way in which this database handles transaction rollbacks after an error has occurred. The initial query has been modified to no longer rely upon catching an error when attempting to detect the appropriate system view. Additionally, to better support this database’s very specific “rollback” behavior, implemented new parameter ignore_no_transaction_on_rollback indicating that a rollback should ignore Azure Synapse error ‘No corresponding transaction found. (111214)’, which is raised if no transaction is present in conflict with the Python DBAPI. Initial patch and valuable debugging assistance courtesy of @ww2406. See also: Avoiding transaction-related exceptions on Azure Synapse Analytics References: #8231 * misc + [bug] [types] Fixed issue where TypeDecorator would not correctly proxy the __getitem__() operator when decorating the ARRAY datatype, without explicit workarounds. References: #7249 * Sat Jul 09 2022 Arun Persaud <arun@gmx.de> - update to version 1.4.39: * orm + [orm] [bug] [regression] Fixed regression caused by #8133 where the pickle format for mutable attributes was changed, without a fallback to recognize the old format, causing in-place upgrades of SQLAlchemy to no longer be able to read pickled data from previous versions. A check plus a fallback for the old format is now in place. References: #8133 - changes from version 1.4.38: * orm + [orm] [bug] [regression] Fixed regression caused by #8064 where a particular check for column correspondence was made too liberal, resulting in incorrect rendering for some ORM subqueries such as those using PropComparator.has() or PropComparator.any() in conjunction with joined-inheritance queries that also use legacy aliasing features. References: [#8162] + [orm] [bug] [sql] Fixed an issue where GenerativeSelect.fetch() would not be applied when executing a statement using the ORM. References: #8091 + [orm] [bug] Fixed issue where a with_loader_criteria() option could not be pickled, as is necessary when it is carried along for propagation to lazy loaders in conjunction with a caching scheme. Currently, the only form that is supported as picklable is to pass the “where criteria” as a fixed module-level callable function that produces a SQL expression. An ad-hoc “lambda” can’t be pickled, and a SQL expression object is usually not fully picklable directly. References: #8109 * engine + [engine] [bug] Repaired a deprecation warning class decorator that was preventing key objects such as Connection from having a proper __weakref__ attribute, causing operations like Python standard library inspect.getmembers() to fail. References: [#8115] * sql + [sql] [bug] Fixed multiple observed race conditions related to lambda_stmt(), including an initial “dogpile” issue when a new Python code object is initially analyzed among multiple simultaneous threads which created both a performance issue as well as some internal corruption of state. Additionally repaired observed race condition which could occur when “cloning” an expression construct that is also in the process of being compiled or otherwise accessed in a different thread due to memoized attributes altering the __dict__ while iterated, for Python versions prior to 3.10; in particular the lambda SQL construct is sensitive to this as it holds onto a single statement object persistently. The iteration has been refined to use dict.copy() with or without an additional iteration instead. References: #8098 + [sql] [bug] Enhanced the mechanism of Cast and other “wrapping” column constructs to more fully preserve a wrapped Label construct, including that the label name will be preserved in the .c collection of a Subquery. The label was already able to render in the SQL correctly on the outside of the construct which it was wrapped inside. References: #8084 + [sql] [bug] Adjusted the fix made for #8056 which adjusted the escaping of bound parameter names with special characters such that the escaped names were translated after the SQL compilation step, which broke a published recipe on the FAQ illustrating how to merge parameter names into the string output of a compiled SQL string. The change restores the escaped names that come from compiled.params and adds a conditional parameter to SQLCompiler.construct_params() named escape_names that defaults to True, restoring the old behavior by default. References: [#8113] * schema + [schema] [bug] Fixed bugs involving the Table.include_columns and the Table.resolve_fks parameters on Table; these little-used parameters were apparently not working for columns that refer to foreign key constraints. In the first case, not-included columns that refer to foreign keys would still attempt to create a ForeignKey object, producing errors when attempting to resolve the columns for the foreign key constraint within reflection; foreign key constraints that refer to skipped columns are now omitted from the table reflection process in the same way as occurs for Index and UniqueConstraint objects with the same conditions. No warning is produced however, as we likely want to remove the include_columns warnings for all constraints in 2.0. In the latter case, the production of table aliases or subqueries would fail on an FK related table not found despite the presence of resolve_fks=False; the logic has been repaired so that if a related table is not found, the ForeignKey object is still proxied to the aliased table or subquery (these ForeignKey objects are normally used in the production of join conditions), but it is sent with a flag that it’s not resolvable. The aliased table / subquery will then work normally, with the exception that it cannot be used to generate a join condition automatically, as the foreign key information is missing. This was already the behavior for such foreign key constraints produced using non-reflection methods, such as joining Table objects from different MetaData collections. References: #8100, #8101 + [schema] [bug] [mssql] Fixed issue where Table objects that made use of IDENTITY columns with a Numeric datatype would produce errors when attempting to reconcile the “autoincrement” column, preventing construction of the Column from using the Column.autoincrement parameter as well as emitting errors when attempting to invoke an Insert construct. References: #8111 * extensions + [extensions] [bug] Fixed bug in Mutable where pickling and unpickling of an ORM mapped instance would not correctly restore state for mappings that contained multiple Mutable-enabled attributes. References: #8133 * Sat Jun 04 2022 Dirk Müller <dmueller@suse.com> - update to 1.4.37 * details on https://docs.sqlalchemy.org/en/14/changelog/changelog_14.html#change-1.4.37 * Fixed issue where using a column_property() construct containing a subquery against an already-mapped column attribute would not correctly apply ORM-compilation behaviors to the subquery, including that the “IN” expression added for a single-table inherits expression would fail to be included. * Fixed issue where ORM results would apply incorrect key names to the returned Row objects in the case where the set of columns to be selected were changed, such as when using Select.with_only_columns(). * Fixed bug, likely a regression from 1.3, where usage of column names that require bound parameter escaping, more concretely when using Oracle with column names that require quoting such as those that start with an underscore, or in less common cases with some PostgreSQL drivers when using column names that contain percent signs, would cause the ORM versioning feature to not work correctly if the versioning column itself had such a name, as the ORM assumes certain bound parameter naming conventions that were being interfered with via the quotes. This issue is related to #8053 and essentially revises the approach towards fixing this, revising the original issue #5653 that created the initial implementation for generalized bound-parameter name quoting. * Wed May 04 2022 Dirk Müller <dmueller@suse.com> - update to 1.4.36: * details on https://docs.sqlalchemy.org/en/14/changelog/changelog_14.html#change-1.4.36 * Fixed regression where the change made for #7861, released in version 1.4.33, that brought the Insert construct to be partially recognized as an ORM-enabled statement * Modified the DeclarativeMeta metaclass to pass cls.__dict__ into the declarative scanning process to look for attributes, rather than the separate dictionary passed to the type’s __init__() method * Fixed a memory leak in the C extensions which could occur when calling upon named members of Row when the member does not exist under Python 3 * Added a warning regarding a bug which exists in the Result.columns() method when passing 0 for the index in conjunction with a Result that will return a single ORM entity, which indicates that the current behavior of Result.columns() is broken in this case as the Result object will yield scalar values and not Row objects * Fixed bug where ForeignKeyConstraint naming conventions using the referred_column_0 naming convention key would not work if the foreign key constraint were set up as a ForeignKey object rather than an explicit ForeignKeyConstraint object. * Wed Apr 20 2022 pgajdos@suse.com - python-mock is not required for build * Sun Apr 10 2022 Arun Persaud <arun@gmx.de> - update to version 1.4.35: * sql + [sql] [bug] Fixed bug in newly implemented FunctionElement.table_valued.joins_implicitly feature where the parameter would not automatically propagate from the original TableValuedAlias object to the secondary object produced when calling upon TableValuedAlias.render_derived() or TableValuedAlias.alias(). Additionally repaired these issues in TableValuedAlias: - repaired a potential memory issue which could occur when repeatedly calling TableValuedAlias.render_derived() against successive copies of the same object (for .alias(), we currently have to still continue chaining from the previous element. not sure if this can be improved but this is standard behavior for .alias() elsewhere) - repaired issue where the individual element types would be lost when calling upon TableValuedAlias.render_derived() or TableValuedAlias.alias(). References: #7890 + [sql] [bug] [regression] Fixed regression caused by #7823 which impacted the caching system, such that bound parameters that had been “cloned” within ORM operations, such as polymorphic loading, would in some cases not acquire their correct execution-time value leading to incorrect bind values being rendered. References: #7903 - changes from version 1.4.34: * orm + [orm] [bug] [regression] Fixed regression caused by #7861 where invoking an Insert construct which contained ORM entities directly via Session.execute() would fail. References: #7878 * postgresql + [postgresql] [bug] Scaled back a fix made for #6581 where “executemany values” mode for psycopg2 were disabled for all “ON CONFLICT” styles of INSERT, to not apply to the “ON CONFLICT DO NOTHING” clause, which does not include any parameters and is safe for “executemany values” mode. “ON CONFLICT DO UPDATE” is still blocked from “executemany values” as there may be additional parameters in the DO UPDATE clause that cannot be batched (which is the original issue fixed by #6581). References: #7880 - changes from version 1.4.33: * orm + [orm] [usecase] Added with_polymorphic.adapt_on_names to the with_polymorphic() function, which allows a polymorphic load (typically with concrete mapping) to be stated against an alternative selectable that will adapt to the original mapped selectable on column names alone. References: #7805 + [orm] [usecase] Added new attributes UpdateBase.returning_column_descriptions and UpdateBase.entity_description to allow for inspection of ORM attributes and entities that are installed as part of an Insert, Update, or Delete construct. The Select.column_descriptions accessor is also now implemented for Core-only selectables. References: #7861 + [orm] [bug] [regression] Fixed regression in “dynamic” loader strategy where the Query.filter_by() method would not be given an appropriate entity to filter from, in the case where a “secondary” table were present in the relationship being queried and the mapping were against something complex such as a “with polymorphic”. References: #7868 + [orm] [bug] Fixed bug where composite() attributes would not work in conjunction with the selectin_polymorphic() loader strategy for joined table inheritance. References: #7801 + [orm] [bug] [performance] Improvements in memory usage by the ORM, removing a significant set of intermediary expression objects that are typically stored when a copy of an expression object is created. These clones have been greatly reduced, reducing the number of total expression objects stored in memory by ORM mappings by about 30%. References: #7823 + [orm] [bug] Fixed issue where the selectin_polymorphic() loader option would not work with joined inheritance mappers that don’t have a fixed “polymorphic_on” column. Additionally added test support for a wider variety of usage patterns with this construct. References: #7799 + [orm] [bug] Fixed bug in with_loader_criteria() function where loader criteria would not be applied to a joined eager load that were invoked within the scope of a refresh operation for the parent object. References: #7862 + [orm] [bug] Fixed issue where the Mapper would reduce a user-defined Mapper.primary_key argument too aggressively, in the case of mapping to a UNION where for some of the SELECT entries, two columns are essentially equivalent, but in another, they are not, such as in a recursive CTE. The logic here has been changed to accept a given user-defined PK as given, where columns will be related to the mapped selectable but no longer “reduced” as this heuristic can’t accommodate for all situations. References: #7842 * engine + [engine] [usecase] Added new parameter Engine.dispose.close, defaulting to True. When False, the engine disposal does not touch the connections in the old pool at all, simply dropping the pool and replacing it. This use case is so that when the original pool is transferred from a parent process, the parent process may continue to use those connections. See also Using Connection Pools with Multiprocessing or os.fork() - revised documentation References: #7815, #7877 + [engine] [bug] Further clarified connection-level logging to indicate the BEGIN, ROLLBACK and COMMIT log messages do not actually indicate a real transaction when the AUTOCOMMIT isolation level is in use; messaging has been extended to include the BEGIN message itself, and the messaging has also been fixed to accommodate when the Engine level create_engine.isolation_level parameter was used directly. References: #7853 * sql + [sql] [usecase] Added new parameter FunctionElement.table_valued.joins_implicitly, for the FunctionElement.table_valued() construct. This parameter indicates that the given table-valued function implicitly joins to the table it refers towards, essentially disabling the “from linting” feature, i.e. the “cartesian product” warning, from taking effect due to the presence of this parameter. May be used for functions such as func.json_each(). References: #7845 + [sql] [bug] The bindparam.literal_execute parameter now takes part of the cache generation of a bindparam(), since it changes the sql string generated by the compiler. Previously the correct bind values were used, but the literal_execute would be ignored on subsequent executions of the same query. References: #7876 + [sql] [bug] [regression] Fixed regression caused by #7760 where the new capabilities of TextualSelect were not fully implemented within the compiler properly, leading to issues with composed INSERT constructs such as “INSERT FROM SELECT” and “INSERT…ON CONFLICT” when combined with CTE and textual statements. References: #7798 * schema + [schema] [usecase] Added support so that the Table.to_metadata.referred_schema_fn callable passed to Table.to_metadata() may return the value BLANK_SCHEMA to indicate that the referenced foreign key should be reset to None. The RETAIN_SCHEMA symbol may also be returned from this function to indicate “no change”, which will behave the same as None currently does which also indicates no change. References: [#7860] * sqlite + [sqlite] [bug] [reflection] Fixed bug where the name of CHECK constraints under SQLite would not be reflected if the name were created using quotes, as is the case when the name uses mixed case or special characters. References: #5463 * mssql + [mssql] [bug] [regression] Fixed regression caused by #7160 where FK reflection in conjunction with a low compatibility level setting (compatibility level 80: SQL Server 2000) causes an “Ambiguous column name” error. Patch courtesy @Lin-Your. References: #7812 * misc + [bug] [ext] Improved the error message that’s raised for the case where the association_proxy() construct attempts to access a target attribute at the class level, and this access fails. The particular use case here is when proxying to a hybrid attribute that does not include a working class-level implementation. References: #7827 * Sat Mar 12 2022 Arun Persaud <arun@gmx.de> - update to version 1.4.32: * orm + [orm] [bug] [regression] Fixed regression where the ORM exception that is to be raised when an INSERT silently fails to actually insert a row (such as from a trigger) would not be reached, due to a runtime exception raised ahead of time due to the missing primary key value, thus raising an uninformative exception rather than the correct one. For 1.4 and above, a new FlushError is added for this case that’s raised earlier than the previous “null identity” exception was for 1.3, as a situation where the number of rows actually INSERTed does not match what was expected is a more critical situation in 1.4 as it prevents batching of multiple objects from working correctly. This is separate from the case where a newly fetched primary key is fetched as NULL, which continues to raise the existing “null identity” exception. References: #7594 + [orm] [bug] Fixed issue where using a fully qualified path for the classname in relationship() that nonetheless contained an incorrect name for path tokens that were not the first token, would fail to raise an informative error and would instead fail randomly at a later step. References: #7697 * engine + [engine] [bug] Adjusted the logging for key SQLAlchemy components including Engine, Connection to establish an appropriate stack level parameter, so that the Python logging tokens funcName and lineno when used in custom logging formatters will report the correct information, which can be useful when filtering log output; supported on Python 3.8 and above. Pull request courtesy Markus Gerstel. References: #7612 * sql + [sql] [bug] Fixed type-related error messages that would fail for values that were tuples, due to string formatting syntax, including compile of unsupported literal values and invalid boolean values. References: #7721 + [sql] [bug] [mysql] Fixed issues in MySQL SET datatype as well as the generic Enum datatype where the __repr__() method would not render all optional parameters in the string output, impacting the use of these types in Alembic autogenerate. Pull request for MySQL courtesy Yuki Nishimine. References: #7598, [#7720], #7789 + [sql] [bug] The Enum datatype now emits a warning if the Enum.length argument is specified without also specifying Enum.native_enum as False, as the parameter is otherwise silently ignored in this case, despite the fact that the Enum datatype will still render VARCHAR DDL on backends that don’t have a native ENUM datatype such as SQLite. This behavior may change in a future release so that “length” is honored for all non-native “enum” types regardless of the “native_enum” setting. + [sql] [bug] Fixed issue where the HasCTE.add_cte() method as called upon a TextualSelect instance was not being accommodated by the SQL compiler. The fix additionally adds more “SELECT”-like compiler behavior to TextualSelect including that DML CTEs such as UPDATE and INSERT may be accommodated. References: #7760 * asyncio + [asyncio] [bug] Fixed issues where a descriptive error message was not raised for some classes of event listening with an async engine, which should instead be a sync engine instance. + [asyncio] [bug] Fixed issue where the AsyncSession.execute() method failed to raise an informative exception if the Connection.execution_options.stream_results execution option were used, which is incompatible with a sync-style Result object when using an asyncio calling style, as the operation to fetch more rows would need to be awaited. An exception is now raised in this scenario in the same way one was already raised when the Connection.execution_options.stream_results option would be used with the AsyncConnection.execute() method. Additionally, for improved stability with state-sensitive database drivers such as asyncmy, the cursor is now closed when this error condition is raised; previously with the asyncmy dialect, the connection would go into an invalid state with unconsumed server side results remaining. References: #7667 * postgresql + [postgresql] [usecase] Added compiler support for the PostgreSQL NOT VALID phrase when rendering DDL for the CheckConstraint, ForeignKeyConstraint and ForeignKey schema constructs. Pull request courtesy Gilbert Gilb’s. References: #7600 * mysql + [mysql] [bug] [regression] Fixed regression caused by #7518 where changing the syntax “SHOW VARIABLES” to “SELECT @@” broke compatibility with MySQL versions older than 5.6, including early 5.0 releases. While these are very old MySQL versions, a change in compatibility was not planned, so version-specific logic has been restored to fall back to “SHOW VARIABLES” for MySQL server versions < 5.6. References: #7518 * mariadb + [mariadb] [bug] [regression] Fixed regression in mariadbconnector dialect as of mariadb connector 1.0.10 where the DBAPI no longer pre-buffers cursor.lastrowid, leading to errors when inserting objects with the ORM as well as causing non-availability of the CursorResult.inserted_primary_key attribute. The dialect now fetches this value proactively for situations where it applies. References: #7738 * sqlite + [sqlite] [usecase] Added support for reflecting SQLite inline unique constraints where the column names are formatted with SQLite “escape quotes” [] or `, which are discarded by the database when producing the column name. References: #7736 + [sqlite] [bug] Fixed issue where SQLite unique constraint reflection would fail to detect a column-inline UNIQUE constraint where the column name had an underscore in its name. References: #7736 * oracle + [oracle] [bug] Fixed issue in Oracle dialect where using a column name that requires quoting when written as a bound parameter, such as "_id", would not correctly track a Python generated default value due to the bound-parameter rewriting missing this value, causing an Oracle error to be raised. References: #7676 + [oracle] [bug] [regression] Added support to parse “DPI” error codes from cx_Oracle exception objects such as DPI-1080 and DPI-1010, both of which now indicate a disconnect scenario as of cx_Oracle 8.3. References: #7748 * tests + [tests] [bug] Improvements to the test suite’s integration with pytest such that the “warnings” plugin, if manually enabled, will not interfere with the test suite, such that third parties can enable the warnings plugin or make use of the -W parameter and SQLAlchemy’s test suite will continue to pass. Additionally, modernized the detection of the “pytest-xdist” plugin so that plugins can be globally disabled using PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 without breaking the test suite if xdist were still installed. Warning filters that promote deprecation warnings to errors are now localized to SQLAlchemy-specific warnings, or within SQLAlchemy-specific sources for general Python deprecation warnings, so that non-SQLAlchemy deprecation warnings emitted from pytest plugins should also not impact the test suite. References: #7599 + [tests] [bug] Made corrections to the default pytest configuration regarding how test discovery is configured, to fix issue where the test suite would not configure warnings correctly and also attempt to load example suites as tests, in the specific case where the SQLAlchemy checkout were located in an absolute path that had a super-directory named “test”. References: #7045 * Sat Jan 29 2022 Arun Persaud <arun@gmx.de> - specfile: * update copyright year - update to version 1.4.31: * orm + [orm] [bug] Fixed issue in Session.bulk_save_objects() where the sorting that takes place when the preserve_order parameter is set to False would sort partially on Mapper objects, which is rejected in Python 3.11. References: #7591 * postgresql + [postgresql] [bug] [regression] Fixed regression where the change in #7148 to repair ENUM handling in PostgreSQL broke the use case of an empty ARRAY of ENUM, preventing rows that contained an empty array from being handled correctly when fetching results. References: #7590 * mysql + [mysql] [bug] [regression] Fixed regression in asyncmy dialect caused by #7567 where removal of the PyMySQL dependency broke binary columns, due to the asyncmy dialect not being properly included within CI tests. References: #7593 * mssql + [mssql] Added support for FILESTREAM when using VARBINARY(max) in MSSQL. References: #7243 - changes from version 1.4.30: * orm + [orm] [bug] Fixed issue in joined-inheritance load of additional attributes functionality in deep multi-level inheritance where an intermediary table that contained no columns would not be included in the tables joined, instead linking those tables to their primary key identifiers. While this works fine, it nonetheless in 1.4 began producing the cartesian product compiler warning. The logic has been changed so that these intermediary tables are included regardless. While this does include additional tables in the query that are not technically necessary, this only occurs for the highly unusual case of deep 3+ level inheritance with intermediary tables that have no non primary key columns, potential performance impact is therefore expected to be negligible. References: #7507 + [orm] [bug] Fixed issue where calling upon registry.map_imperatively() more than once for the same class would produce an unexpected error, rather than an informative error that the target class is already mapped. This behavior differed from that of the mapper() function which does report an informative message already. References: #7579 + [orm] [bug] [asyncio] Added missing method AsyncSession.invalidate() to the AsyncSession class. References: #7524 + [orm] [bug] [regression] Fixed regression which appeared in 1.4.23 which could cause loader options to be mis-handled in some cases, in particular when using joined table inheritance in combination with the polymorphic_load="selectin" option as well as relationship lazy loading, leading to a TypeError. References: #7557 + [orm] [bug] [regression] Fixed ORM regression where calling the aliased() function against an existing aliased() construct would fail to produce correct SQL if the existing construct were against a fixed table. The fix allows that the original aliased() construct is disregarded if it were only against a table that’s now being replaced. It also allows for correct behavior when constructing a aliased() without a selectable argument against a aliased() that’s against a subuquery, to create an alias of that subquery (i.e. to change its name). The nesting behavior of aliased() remains in place for the case where the outer aliased() object is against a subquery which in turn refers to the inner aliased() object. This is a relatively new 1.4 feature that helps to suit use cases that were previously served by the deprecated Query.from_self() method. References: #7576 + [orm] [bug] Fixed issue where Select.correlate_except() method, when passed either the None value or no arguments, would not correlate any elements when used in an ORM context (that is, passing ORM entities as FROM clauses), rather than causing all FROM elements to be considered as “correlated” in the same way which occurs when using Core-only constructs. References: #7514 + [orm] [bug] [regression] Fixed regression from 1.3 where the “subqueryload” loader strategy would fail with a stack trace if used against a query that made use of Query.from_statement() or Select.from_statement(). As subqueryload requires modifying the original statement, it’s not compatible with the “from_statement” use case, especially for statements made against the text() construct. The behavior now is equivalent to that of 1.3 and previously, which is that the loader strategy silently degrades to not be used for such statements, typically falling back to using the lazyload strategy. References: #7505 * sql + [sql] [bug] [postgresql] Added additional rule to the system that determines TypeEngine implementations from Python literals to apply a second level of adjustment to the type, so that a Python datetime with or without tzinfo can set the timezone=True parameter on the returned DateTime object, as well as Time. This helps with some round-trip scenarios on type-sensitive PostgreSQL dialects such as asyncpg, psycopg3 (2.0 only). References: #7537 + [sql] [bug] Added an informative error message when a method object is passed to a SQL construct. Previously, when such a callable were passed, as is a common typographical error when dealing with method-chained SQL constructs, they were interpreted as “lambda SQL” targets to be invoked at compilation time, which would lead to silent failures. As this feature was not intended to be used with methods, method objects are now rejected. References: #7032 * mypy + [mypy] [bug] Fixed Mypy crash when running id daemon mode caused by a missing attribute on an internal mypy Var instance. References: #7321 * asyncio + [asyncio] [usecase] Added new method AdaptedConnection.run_async() to the DBAPI connection interface used by asyncio drivers, which allows methods to be called against the underlying “driver” connection directly within a sync-style function where the await keyword can’t be used, such as within SQLAlchemy event handler functions. The method is analogous to the AsyncConnection.run_sync() method which translates async-style calls to sync-style. The method is useful for things like connection-pool on-connect handlers that need to invoke awaitable methods on the driver connection when it’s first created. References: #7580 * postgresql + [postgresql] [usecase] Added string rendering to the UUID datatype, so that stringifying a statement with “literal_binds” that uses this type will render an appropriate string value for the PostgreSQL backend. Pull request courtesy José Duarte. References: #7561 + [postgresql] [bug] [asyncpg] Improved support for asyncpg handling of TIME WITH TIMEZONE, which was not fully implemented. References: #7537 + [postgresql] [bug] [mssql] [reflection] Fixed reflection of covering indexes to report include_columns as part of the dialect_options entry in the reflected index dictionary, thereby enabling round trips from reflection->create to be complete. Included columns continue to also be present under the include_columns key for backwards compatibility. References: [#7382] + [postgresql] [bug] Fixed handling of array of enum values which require escape characters. References: #7418 + mysql + [mysql] [change] Replace SHOW VARIABLES LIKE statement with equivalent SELECT @@variable in MySQL and MariaDB dialect initialization. This should avoid mutex contention caused by SHOW VARIABLES, improving initialization performance. References: #7518 + [mysql] [bug] Removed unnecessary dependency on PyMySQL from the asyncmy dialect. Pull request courtesy long2ice. References: [#7567] * Mon Dec 27 2021 Matej Cepl <mcepl@suse.com> - Update to 1.4.29: - truly, just plenty of small bugfixes, see the changelog on the Web https://docs.sqlalchemy.org/en/14/changelog/changelog_14.html#change-1.4.29 * Sat Dec 18 2021 Dirk Müller <dmueller@suse.com> - update to 1.4.28: Bugfixes, see * https://docs.sqlalchemy.org/en/14/changelog/changelog_14.html#change-1.4.28 * Sun Dec 05 2021 Dirk Müller <dmueller@suse.com> - update to 1.4.27: Bugfixes * see https://docs.sqlalchemy.org/en/14/changelog/changelog_14.html#change-1.4.27 * Wed Oct 27 2021 Dirk Müller <dmueller@suse.com> - update to version 1.4.26: * a repair to the workings of the update() statement in an ORM context when used with hybrid and composite attributes. * Fixes for the with_loader_criteria() ORM option * adjustments to the ORM Session interface to accommodate for new API features * some new legacy warnings for lesser used patterns with Query.join() * SQL / ORM fixes for the use case of selecting from repeated, non-labeled column expressions, typically the null() construct when used as a placeholder in a UNION statement. * For PostgreSQL, refinements to the "expanding IN" SQL feature when used with PostgreSQL ARRAY datatypes as well as fixes for the mostly PostgreSQL-specific any_() and all_() column methods. * For MySQL, repaired support for new behaviors in MariaDB 10.6 * For SQL Server, reflection fixes and improvements for foreign key constraints as well table /view detection. * Sat Oct 16 2021 Dirk Müller <dmueller@suse.com> - update to version 1.4.25: * Fixed regression due to :ticket:`7024` where the reorganization of the "platform machine" names used by the ``greenlet`` dependency mis-spelled "aarch64" and additionally omitted uppercase "AMD64" as is needed for Windows machines. * Fixed a bug in :meth:`_asyncio.AsyncSession.execute` and :meth:`_asyncio.AsyncSession.stream` that required ``execution_options`` to be an instance of ``immutabledict`` when defined. It now correctly accepts any mapping. * Improve the interface used by adapted drivers, like the asyncio ones, to access the actual connection object returned by the driver. * Implemented missing methods in :class:`_functions.FunctionElement` which, while unused, would lead pylint to report them as unimplemented abstract methods. * Fixed an issue where :meth:`_reflection.has_table` returned ``True`` for local temporary tables that actually belonged to a different SQL Server session (connection). An extra check is now performed to ensure that the temp table detected is in fact owned by the current session. * Fixed issue where the ability of the :meth:`_events.ConnectionEvents.before_execute` method to alter the SQL statement object passed, returning the new object to be invoked, was inadvertently removed. This behavior has been restored. * Ensure that ``str()`` is called on the an :paramref:`_url.URL.create.password` argument, allowing usage of objects that implement the ``__str__()`` method as password attributes. Also clarified that one such object is not appropriate to dynamically change the password for each database connection; the approaches at :ref:`engines_dynamic_tokens` should be used instead. * Fixed ORM issue where column expressions passed to ``query()`` or ORM-enabled ``select()`` would be deduplicated on the identity of the object, such as a phrase like ``select(A.id, null(), null())`` would produce only one "NULL" expression, which previously was not the case in 1.3. However, the change also allows for ORM expressions to render as given as well, such as ``select(A.data, A.data)`` will produce a result row with two columns. * Fixed issue where mypy plugin would crash when interpreting a ``query_expression()`` construct. * Added new methods :meth:`_orm.Session.scalars`, * Added loader options to :meth:`_orm.Session.merge` and :meth:`_asyncio.AsyncSession.merge` via a new :paramref:`_orm.Session.merge.options` parameter, which will apply the given loader options to the ``get()`` used internally by merge, allowing eager loading of relationships etc. to be applied when the merge process loads a new object. Pull request courtesy Daniel Stone. * Added initial support for the ``asyncmy`` asyncio database driver for MySQL and MariaDB. This driver is very new, however appears to be the only current alternative to the ``aiomysql`` driver which currently appears to be unmaintained and is not working with current Python versions. Much thanks to long2ice for the pull request for this dialect. * Fixed a two issues where combinations of ``select()`` and ``join()`` when adapted to form a copy of the element would not completely copy the state of all column objects associated with subqueries. A key problem this caused is that usage of the :meth:`_sql.ClauseElement.params` method (which should probably be moved into a legacy category as it is inefficient and error prone) would leave copies of the old :class:`_sql.BindParameter` objects around, leading to issues in correctly setting the parameters at execution time. * Thu Jul 22 2021 Arun Persaud <arun@gmx.de> - update to version 1.4.22: * orm + Fixed issue in new Table.table_valued() method where the resulting TableValuedColumn construct would not respond correctly to alias adaptation as is used throughout the ORM, such as for eager loading, polymorphic loading, etc. + Fixed issue where usage of the Result.unique() method with an ORM result that included column expressions with unhashable types, such as JSON or ARRAY using non-tuples would silently fall back to using the id() function, rather than raising an error. This now raises an error when the Result.unique() method is used in a 2.0 style ORM query. Additionally, hashability is assumed to be True for result values of unknown type, such as often happens when using SQL functions of unknown return type; if values are truly not hashable then the hash() itself will raise. + For legacy ORM queries, since the legacy Query object uniquifies in all cases, the old rules remain in place, which is to use id() for result values of unknown type as this legacy uniquing is mostly for the purpose of uniquing ORM entities and not column values. + Fixed an issue where clearing of mappers during things like test suite teardowns could cause a “dictionary changed size” warning during garbage collection, due to iteration of a weak-referencing dictionary. A list() has been applied to prevent concurrent GC from affecting this operation. + Fixed critical caching issue where the ORM’s persistence feature using INSERT..RETURNING would cache an incorrect query when mixing the “bulk save” and standard “flush” forms of INSERT. * engine + Added some guards against KeyError in the event system to accommodate the case that the interpreter is shutting down at the same time Engine.dispose() is being called, which would cause stack trace warnings. * sql + Fixed issue where use of the case.whens parameter passing a dictionary positionally and not as a keyword argument would emit a 2.0 deprecation warning, referring to the deprecation of passing a list positionally. The dictionary format of “whens”, passed positionally, is still supported and was accidentally marked as deprecated. + Fixed issue where type-specific bound parameter handlers would not be called upon in the case of using the Insert.values() method with the Python None value; in particular, this would be noticed when using the JSON datatype as well as related PostgreSQL specific types such as JSONB which would fail to encode the Python None value into JSON null, however the issue was generalized to any bound parameter handler in conjunction with this specific method of Insert. - changes from version 1.4.21: * orm + Modified the approach used for history tracking of scalar object relationships that are not many-to-one, i.e. one-to-one relationships that would otherwise be one-to-many. When replacing a one-to-one value, the “old” value that would be replaced is no longer loaded immediately, and is instead handled during the flush process. This eliminates an historically troublesome lazy load that otherwise often occurs when assigning to a one-to-one attribute, and is particularly troublesome when using “lazy=’raise’” as well as asyncio use cases. + This change does cause a behavioral change within the AttributeEvents.set() event, which is nonetheless currently documented, which is that the event applied to such a one-to-one attribute will no longer receive the “old” parameter if it is unloaded and the relationship.active_history flag is not set. As is documented in AttributeEvents.set(), if the event handler needs to receive the “old” value when the event fires off, the active_history flag must be established either with the event listener or with the relationship. This is already the behavior with other kinds of attributes such as many-to-one and column value references. + The change additionally will defer updating a backref on the “old” value in the less common case that the “old” value is locally present in the session, but isn’t loaded on the relationship in question, until the next flush occurs. If this causes an issue, again the normal relationship.active_history flag can be set to True on the relationship. + Fixed regression caused in 1.4.19 due to #6503 and related involving Query.with_entities() where the new structure used would be inappropriately transferred to an enclosing Query when making use of set operations such as Query.union(), causing the JOIN instructions within to be applied to the outside query as well. + Fixed regression which appeared in version 1.4.3 due to #6060 where rules that limit ORM adaptation of derived selectables interfered with other ORM-adaptation based cases, in this case when applying adaptations for a with_polymorphic() against a mapping which uses a column_property() which in turn makes use of a scalar select that includes a aliased() object of the mapped table. + Fixed ORM regression where ad-hoc label names generated for hybrid properties and potentially other similar types of ORM-enabled expressions would usually be propagated outwards through subqueries, allowing the name to be retained in the final keys of the result set even when selecting from subqueries. Additional state is now tracked in this case that isn’t lost when a hybrid is selected out of a Core select / subquery. * sql + Added new method HasCTE.add_cte() to each of the select(), insert(), update() and delete() constructs. This method will add the given CTE as an “independent” CTE of the statement, meaning it renders in the WITH clause above the statement unconditionally even if it is not otherwise referenced in the primary statement. This is a popular use case on the PostgreSQL database where a CTE is used for a DML statement that runs against database rows independently of the primary statement. + Fixed issue in CTE constructs where a recursive CTE that referred to a SELECT that has duplicate column names, which are typically deduplicated using labeling logic in 1.4, would fail to refer to the deduplicated label name correctly within the WITH clause. + Fixed regression where the tablesample() construct would fail to be executable when constructed given a floating-point sampling value not embedded within a SQL function. * postgresql + Fixed issue in Insert.on_conflict_do_nothing() and Insert.on_conflict_do_update() where the name of a unique constraint passed as the constraint parameter would not be properly truncated for length if it were based on a naming convention that generated a too-long name for the PostgreSQL max identifier length of 63 characters, in the same way which occurs within a CREATE TABLE statement. + Fixed issue where the PostgreSQL ENUM datatype as embedded in the ARRAY datatype would fail to emit correctly in create/drop when the schema_translate_map feature were also in use. Additionally repairs a related issue where the same schema_translate_map feature would not work for the ENUM datatype in combination with a CAST, that’s also intrinsic to how the ARRAY(ENUM) combination works on the PostgreSQL dialect. + Fixed issue in Insert.on_conflict_do_nothing() and Insert.on_conflict_do_update() where the name of a unique constraint passed as the constraint parameter would not be properly quoted if it contained characters which required quoting. * mssql + Fixed regression where the special dotted-schema name handling for the SQL Server dialect would not function correctly if the dotted schema name were used within the schema_translate_map feature. * Sun Jul 11 2021 Antonio Larrosa <alarrosa@suse.com> - update to version 1.4.20: * orm + [orm] [bug] [regression] Fixed regression in ORM regarding an internal reconstitution step for the with_polymorphic() construct, when the user-facing object is garbage collected as the query is processed. The reconstitution was not ensuring the sub-entities for the “polymorphic” case were handled, leading to an AttributeError. References: #6680 + [orm] [bug] [regression] Adjusted Query.union() and similar set operations to be correctly compatible with the new capabilities just added in #6661, with SQLAlchemy 1.4.19, such that the SELECT statements rendered as elements of the UNION or other set operation will include directly mapped columns that are mapped as deferred; this both fixes a regression involving unions with multiple levels of nesting that would produce a column mismatch, and also allows the undefer() option to be used at the top level of such a Query without having to apply the option to each of the elements within the UNION. References: #6678 + [orm] [bug] Adjusted the check in the mapper for a callable object that is used as a @validates validator function or a @reconstructor reconstruction function, to check for “callable” more liberally such as to accommodate objects based on fundamental attributes like __func__ and __call___, rather than testing for MethodType / FunctionType, allowing things like cython functions to work properly. Pull request courtesy Miłosz Stypiński. References: #6538 * engine + [engine] [bug] Fixed an issue in the C extension for the Row class which could lead to a memory leak in the unlikely case of a Row object which referred to an ORM object that then was mutated to refer back to the Row itself, creating a cycle. The Python C APIs for tracking GC cycles has been added to the native Row implementation to accommodate for this case. References: #5348 + [engine] [bug] Fixed old issue where a select() made against the token “*”, which then yielded exactly one column, would fail to correctly organize the cursor.description column name into the keys of the result object. References: #6665 * sql + [sql] [usecase] Add a impl parameter to PickleType constructor, allowing any arbitary type to be used in place of the default implementation of LargeBinary. Pull request courtesy jason3gb. References: #6646 + [sql] [bug] [orm] Fixed the class hierarchy for the Sequence and the more general DefaultGenerator base, as these are “executable” as statements they need to include Executable in their hierarchy, not just StatementRole as was applied arbitrarily to Sequence previously. The fix allows Sequence to work in all .execute() methods including with Session.execute() which was not working in the case that a SessionEvents.do_orm_execute() handler was also established. References: #6668 * schema + [schema] [bug] Fixed issue where passing None for the value of Table.prefixes would not store an empty list, but rather the constant None, which may be unexpected by third party dialects. The issue is revealed by a usage in recent versions of Alembic that are passing None for this value. Pull request courtesy Kai Mueller. References: #6685 * mysql + [mysql] [usecase] Made a small adjustment in the table reflection feature of the MySQL dialect to accommodate for alternate MySQL-oriented databases such as TiDB which include their own “comment” directives at the end of a constraint directive within “CREATE TABLE” where the format doesn’t have the additional space character after the comment, in this case the TiDB “clustered index” feature. Pull request courtesy Daniël van Eeden. References: #6659 * misc + [bug] [ext] [regression] Fixed regression in sqlalchemy.ext.automap extension such that the use case of creating an explicit mapped class to a table that is also the relationship.secondary element of a relationship() that automap will be generating would emit the “overlaps” warnings introduced in 1.4 and discussed at relationship X will copy column Q to column P, which conflicts with relationship(s): ‘Y’. While generating this case from automap is still subject to the same caveats that the “overlaps” warning refers towards, as automap is intended for more ad-hoc use cases, the condition which produces the warning is disabled when a many-to-many relationship with this particular pattern is generated. References: #6679 - changes from version 1.4.19: * orm + [orm] [bug] [regression] Fixed further regressions in the same area as that of #6052 where loader options as well as invocations of methods like Query.join() would fail if the left side of the statement for which the option/join depends upon were replaced by using the Query.with_entities() method, or when using 2.0 style queries when using the Select.with_only_columns() method. A new set of state has been added to the objects which tracks the “left” entities that the options / join were made against which is memoized when the lead entities are changed. References: #6253, #6503 + [orm] [bug] Refined the behavior of ORM subquery rendering with regards to deferred columns and column properties to be more compatible with that of 1.3 while also providing for 1.4’s newer features. As a subquery in 1.4 does not make use of loader options, including undefer(), a subquery that is against an ORM entity with deferred attributes will now render those deferred attributes that refer directly to mapped table columns, as these are needed in the outer SELECT if that outer SELECT makes use of these columns; however a deferred attribute that refers to a composed SQL expression as we normally do with column_property() will not be part of the subquery, as these can be selected explicitly if needed in the subquery. If the entity is being SELECTed from this subquery, the column expression can still render on “the outside” in terms of the derived subquery columns. This produces essentially the same behavior as when working with 1.3. However in this case the fix has to also make sure that the .selected_columns collection of an ORM-enabled select() also follows these rules, which in particular allows recursive CTEs to render correctly in this scenario, which were previously failing to render correctly due to this issue. References: #6661 * sql + [sql] [bug] Fixed issue in CTE constructs mostly relevant to ORM use cases where a recursive CTE against “anonymous” labels such as those seen in ORM column_property() mappings would render in the WITH RECURSIVE xyz(...) section as their raw internal label and not a cleanly anonymized name. References: #6663 * mypy + [mypy] [bug] Fixed issue in mypy plugin where class info for a custom declarative base would not be handled correctly on a cached mypy pass, leading to an AssertionError being raised. References: #6476 * asyncio + [asyncio] [usecase] Implemented async_scoped_session to address some asyncio-related incompatibilities between scoped_session and AsyncSession, in which some methods (notably the async_scoped_session.remove() method) should be used with the await keyword. References: #6583 + [asyncio] [bug] [postgresql] Fixed bug in asyncio implementation where the greenlet adaptation system failed to propagate BaseException subclasses, most notably including asyncio.CancelledError, to the exception handling logic used by the engine to invalidate and clean up the connection, thus preventing connections from being correctly disposed when a task was cancelled. References: #6652 * postgresql + [postgresql] [bug] [oracle] Fixed issue where the INTERVAL datatype on PostgreSQL and Oracle would produce an AttributeError when used in the context of a comparison operation against a timedelta() object. Pull request courtesy MajorDallas. References: #6649 + [postgresql] [bug] Fixed issue where the pool “pre ping” feature would implicitly start a transaction, which would then interfere with custom transactional flags such as PostgreSQL’s “read only” mode when used with the psycopg2 driver. References: #6621 * mysql + [mysql] [usecase] Added new construct match, which provides for the full range of MySQL’s MATCH operator including multiple column support and modifiers. Pull request courtesy Anton Kovalevich. References: #6132 * mssql + [mssql] [change] Made improvements to the server version regexp used by the pymssql dialect to prevent a regexp overflow in case of an invalid version string. References: #6253, #6503 + [mssql] [bug] Fixed bug where the “schema_translate_map” feature would fail to function correctly in conjunction with an INSERT into a table that has an IDENTITY column, where the value of the IDENTITY column were specified in the values of the INSERT thus triggering SQLAlchemy’s feature of setting IDENTITY INSERT to “on”; it’s in this directive where the schema translate map would fail to be honored. References: #6658 - changes from version 1.4.18: * orm + [orm] [performance] [bug] [regression] Fixed regression involving how the ORM would resolve a given mapped column to a result row, where under cases such as joined eager loading, a slightly more expensive “fallback” could take place to set up this resolution due to some logic that was removed since 1.3. The issue could also cause deprecation warnings involving column resolution to be emitted when using a 1.4 style query with joined eager loading. References: #6596 + [orm] [bug] Clarified the current purpose of the relationship.bake_queries flag, which in 1.4 is to enable or disable “lambda caching” of statements within the “lazyload” and “selectinload” loader strategies; this is separate from the more foundational SQL query cache that is used for most statements. Additionally, the lazy loader no longer uses its own cache for many-to-one SQL queries, which was an implementation quirk that doesn’t exist for any other loader scenario. Finally, the “lru cache” warning that the lazyloader and selectinloader strategies could emit when handling a wide array of class/relationship combinations has been removed; based on analysis of some end-user cases, this warning doesn’t suggest any significant issue. While setting bake_queries=False for such a relationship will remove this cache from being used, there’s no particular performance gain in this case as using no caching vs. using a cache that needs to refresh often likely still wins out on the caching being used side. References: #6072, #6487 + [orm] [bug] [regression] Adjusted the means by which classes such as scoped_session and AsyncSession are generated from the base Session class, such that custom Session subclasses such as that used by Flask-SQLAlchemy don’t need to implement positional arguments when they call into the superclass method, and can continue using the same argument styles as in previous releases. References: #6285 + [orm] [bug] [regression] Fixed issue where query production for joinedload against a complex left hand side involving joined-table inheritance could fail to produce a correct query, due to a clause adaption issue. References: #6595 + [orm] [bug] Fixed issue in experimental “select ORM objects from INSERT/UPDATE” use case where an error was raised if the statement were against a single-table-inheritance subclass. References: #6591 + [orm] [bug] The warning that’s emitted for relationship() when multiple relationships would overlap with each other as far as foreign key attributes written towards, now includes the specific “overlaps” argument to use for each warning in order to silence the warning without changing the mapping. References: #6400 * asyncio + [asyncio] [usecase] Implemented a new registry architecture that allows the Async version of an object, like AsyncSession, AsyncConnection, etc., to be locatable given the proxied “sync” object, i.e. Session, Connection. Previously, to the degree such lookup functions were used, an Async object would be re-created each time, which was less than ideal as the identity and state of the “async” object would not be preserved across calls. From there, new helper functions async_object_session(), async_session() as well as a new InstanceState attribute InstanceState.async_session have been added, which are used to retrieve the original AsyncSession associated with an ORM mapped object, a Session associated with an AsyncSession, and an AsyncSession associated with an InstanceState, respectively. This patch also implements new methods AsyncSession.in_nested_transaction(), AsyncSession.get_transaction(), AsyncSession.get_nested_transaction(). References: #6319 + [asyncio] [bug] Fixed an issue that presented itself when using the NullPool or the StaticPool with an async engine. This mostly affected the aiosqlite dialect. References: #6575 + [asyncio] [bug] Added asyncio.exceptions.TimeoutError, asyncio.exceptions.CancelledError as so-called “exit exceptions”, a class of exceptions that include things like GreenletExit and KeyboardInterrupt, which are considered to be events that warrant considering a DBAPI connection to be in an unusable state where it should be recycled. References: #6592 * postgresql + [postgresql] [bug] [regression] Fixed regression where using the PostgreSQL “INSERT..ON CONFLICT” structure would fail to work with the psycopg2 driver if it were used in an “executemany” context along with bound parameters in the “SET” clause, due to the implicit use of the psycopg2 fast execution helpers which are not appropriate for this style of INSERT statement; as these helpers are the default in 1.4 this is effectively a regression. Additional checks to exclude this kind of statement from that particular extension have been added. References: #6581 * sqlite + [sqlite] [bug] Add note regarding encryption-related pragmas for pysqlcipher passed in the url. This change is also backported to: 1.3.25. References: #6589 + [sqlite] [bug] [regression] The fix for pysqlcipher released in version 1.4.3 #5848 was unfortunately non-working, in that the new on_connect_url hook was erroneously not receiving a URL object under normal usage of create_engine() and instead received a string that was unhandled; the test suite failed to fully set up the actual conditions under which this hook is called. This has been fixed. References: #6586 - changes from version 1.4.17: * orm + [orm] [bug] [regression] Fixed regression caused by just-released performance fix mentioned in #6550 where a query.join() to a relationship could produce an AttributeError if the query were made against non-ORM structures only, a fairly unusual calling pattern. References: #6558 - changes from version 1.4.16: * general + [general] [bug] Resolved various deprecation warnings which were appearing as of Python version 3.10.0b1. References: #6540, #6543 * orm + [orm] [bug] Fixed issue when using relationship.cascade_backrefs parameter set to False, which per cascade_backrefs behavior deprecated for removal in 2.0 is set to become the standard behavior in SQLAlchemy 2.0, where adding the item to a collection that uniquifies, such as set or dict would fail to fire a cascade event if the object were already associated in that collection via the backref. This fix represents a fundamental change in the collection mechanics by introducing a new event state which can fire off for a collection mutation even if there is no net change on the collection; the action is now suited using a new event hook AttributeEvents.append_wo_mutation(). References: #6471 + [orm] [bug] [regression] Fixed regression involving clause adaption of labeled ORM compound elements, such as single-table inheritance discriminator expressions with conditionals or CASE expressions, which could cause aliased expressions such as those used in ORM join / joinedload operations to not be adapted correctly, such as referring to the wrong table in the ON clause in a join. This change also improves a performance bump that was located within the process of invoking Select.join() given an ORM attribute as a target. References: #6550 + [orm] [bug] [regression] Fixed regression where the full combination of joined inheritance, global with_polymorphic, self-referential relationship and joined loading would fail to be able to produce a query with the scope of lazy loads and object refresh operations that also attempted to render the joined loader. References: #6495 + [orm] [bug] Enhanced the bind resolution rules for Session.execute() so that when a non-ORM statement such as an insert() construct nonetheless is built against ORM objects, to the greatest degree possible the ORM entity will be used to resolve the bind, such as for a Session that has a bind map set up on a common superclass without specific mappers or tables named in the map. References: #6484 * engine + [engine] [bug] Fixed issue where an @ sign in the database portion of a URL would not be interpreted correctly if the URL also had a username:password section. References: #6482 + [engine] [bug] Fixed a long-standing issue with URL where query parameters following the question mark would not be parsed correctly if the URL did not contain a database portion with a backslash. References: #6329 * sql + [sql] [bug] [regression] Fixed regression in dynamic loader strategy and relationship() overall where the relationship.order_by parameter were stored as a mutable list, which could then be mutated when combined with additional “order_by” methods used against the dynamic query object, causing the ORDER BY criteria to continue to grow repetitively. References: #6549 * mssql + [mssql] [usecase] Implemented support for a CTE construct to be used directly as the target of a delete() construct, i.e. “WITH … AS cte DELETE FROM cte”. This appears to be a useful feature of SQL Server. References: #6464 * misc + [bug] [ext] Fixed a deprecation warning that was emitted when using automap_base() without passing an existing Base. References: #6529 + [bug] [pep484] Remove pep484 types from the code. Current effort is around the stub package, and having typing in two places makes thing worse, since the types in the SQLAlchemy source were usually outdated compared to the version in the stubs. References: #6461 + [bug] [ext] [regression] Fixed regression in the sqlalchemy.ext.instrumentation extension that prevented instrumentation disposal from working completely. This fix includes both a 1.4 regression fix as well as a fix for a related issue that existed in 1.3 also. As part of this change, the sqlalchemy.ext.instrumentation.InstrumentationManager class now has a new method unregister(), which replaces the previous method dispose(), which was not called as of version 1.4. References: #6390 - Drop patch: * tests_overcome_bpo42967.patch * Fri May 14 2021 Arun Persaud <arun@gmx.de> - updated line numbers in patch - update to version 1.4.15: * general + [general] [feature] A new approach has been applied to the warnings system in SQLAlchemy to accurately predict the appropriate stack level for each warning dynamically. This allows evaluating the source of SQLAlchemy-generated warnings and deprecation warnings to be more straightforward as the warning will indicate the source line within end-user code, rather than from an arbitrary level within SQLAlchemy’s own source code. * orm + [orm] [bug] [regression] Fixed additional regression caused by “eager loaders run on unexpire” feature #1763 where the feature would run for a contains_eager() eagerload option in the case that the contains_eager() were chained to an additional eager loader option, which would then produce an incorrect query as the original query-bound join criteria were no longer present. + [orm] [bug] Fixed issue in subquery loader strategy which prevented caching from working correctly. This would have been seen in the logs as a “generated” message instead of “cached” for all subqueryload SQL emitted, which by saturating the cache with new keys would degrade overall performance; it also would produce “LRU size alert” warnings. * sql + [sql] [bug] Adjusted the logic added as part of #6397 in 1.4.12 so that internal mutation of the BindParameter object occurs within the clause construction phase as it did before, rather than in the compilation phase. In the latter case, the mutation still produced side effects against the incoming construct and additionally could potentially interfere with other internal mutation routines. * mysql + [mysql] [bug] [documentation] Added support for the ssl_check_hostname= parameter in mysql connection URIs and updated the mysql dialect documentation regarding secure connections. Original pull request courtesy of Jerry Zhao. - changes from version 1.4.14: * orm + [orm] [bug] [regression] Fixed regression involving lazy='dynamic' loader in conjunction with a detached object. The previous behavior was that the dynamic loader upon calling methods like .all() returns empty lists for detached objects without error, this has been restored; however a warning is now emitted as this is not the correct result. Other dynamic loader scenarios correctly raise DetachedInstanceError. * engine + [engine] [usecase] [orm] Applied consistent behavior to the use case of calling .commit() or .rollback() inside of an existing .begin() context manager, with the addition of potentially emitting SQL within the block subsequent to the commit or rollback. This change continues upon the change first added in [#6155] where the use case of calling “rollback” inside of a .begin() contextmanager block was proposed: o calling .commit() or .rollback() will now be allowed without error or warning within all scopes, including that of legacy and future Engine, ORM Session, asyncio AsyncEngine. Previously, the Session disallowed this. o The remaining scope of the context manager is then closed; when the block ends, a check is emitted to see if the transaction was already ended, and if so the block returns without action. o It will now raise an error if subsequent SQL of any kind is emitted within the block, after .commit() or .rollback() is called. The block should be closed as the state of the executable object would otherwise be undefined in this state. + [engine] [bug] [regression] Established a deprecation path for calling upon the CursorResult.keys() method for a statement that returns no rows to provide support for legacy patterns used by the “records” package as well as any other non-migrated applications. Previously, this would raise ResourceClosedException unconditionally in the same way as it does when attempting to fetch rows. While this is the correct behavior going forward, the _cursor.LegacyCursorResult object will now in this case return an empty list for .keys() as it did in 1.3, while also emitting a 2.0 deprecation warning. The _cursor.CursorResult, used when using a 2.0-style “future” engine, will continue to raise as it does now. * sql + [sql] [bug] [regression] Fixed regression caused by the “empty in” change just made in #6397 1.4.12 where the expression needs to be parenthesized for the “not in” use case, otherwise the condition will interfere with the other filtering criteria. + [sql] [bug] [regression] The TypeDecorator class will now emit a warning when used in SQL compilation with caching unless the .cache_ok flag is set to True or False. A new class-level attribute TypeDecorator.cache_ok may be set which will be used as an indication that all the parameters passed to the object are safe to be used as a cache key if set to True, False means they are not. * Thu May 06 2021 Antonio Larrosa <alarrosa@suse.com> - Remove %ifpython2 (python2 flavor is disabled). - Do not use %if %{python_version_nodots} for BuildRequires. * Wed May 05 2021 Antonio Larrosa <alarrosa@suse.com> - Remove broken %ifpython3 since the python2 flavor is disabled anyway. * Tue May 04 2021 Antonio Larrosa <alarrosa@suse.com> - update to 1.4.13: orm * Fixed regression in selectinload loader strategy that would cause it to cache its internal state incorrectly when handling relationships that join across more than one column, such as when using a composite foreign key. The invalid caching would then cause other unrelated loader operations to fail. References: #6410 * Fixed regression where Query.filter_by() would not work if the lead entity were a SQL function or other expression derived from the primary entity in question, rather than a simple entity or column of that entity. Additionally, improved the behavior of Select.filter_by() overall to work with column expressions even in a non-ORM context. References: #6414 * Fixed regression where using selectinload() and subqueryload() to load a two-level-deep path would lead to an attribute error. References: #6419 * Fixed regression where using the noload() loader strategy in conjunction with a “dynamic” relationship would lead to an attribute error as the noload strategy would attempt to apply itself to the dynamic loader. References: #6420 engine * Restored a legacy transactional behavior that was inadvertently removed from the Connection as it was never tested as a known use case in previous versions, where calling upon the Connection.begin_nested() method, when no transaction is present, does not create a SAVEPOINT at all and instead starts an outer transaction, returning a RootTransaction object instead of a NestedTransaction object. This RootTransaction then will emit a real COMMIT on the database connection when committed. Previously, the 2.0 style behavior was present in all cases that would autobegin a transaction but not commit it, which is a behavioral change. When using a 2.0 style connection object, the behavior is unchanged from previous 1.4 versions; calling Connection.begin_nested() will “autobegin” the outer transaction if not already present, and then as instructed emit a SAVEPOINT, returning the NestedTransaction object. The outer transaction is committed by calling upon Connection.commit(), as is “commit-as-you-go” style usage. In non-“future” mode, while the old behavior is restored, it also emits a 2.0 deprecation warning as this is a legacy behavior. References: #6408 asyncio * Fixed a regression introduced by #6337 that would create an asyncio.Lock which could be attached to the wrong loop when instantiating the async engine before any asyncio loop was started, leading to an asyncio error message when attempting to use the engine under certain circumstances. References: #6409 postgresql * Add support for server side cursors in the pg8000 dialect for PostgreSQL. This allows use of the Connection.execution_options.stream_results option. References: #6198 * Tue May 04 2021 Antonio Larrosa <alarrosa@suse.com> - Removed use of pytest-xdist which is giving intermitent failed builds with internal errors like: INTERNALERROR> E RuntimeError: There is no current event loop in thread 'Dummy-1'. [...] INTERNALERROR> /usr/lib/python3.9/site-packages/xdist/ dsession.py:190: AssertionError [gw6] node down: Not properly terminated * Fri Apr 30 2021 Antonio Larrosa <alarrosa@suse.com> - Update to 1.4.12 (bsc#1184038): * There are many changes between the 1.4 and 1.3 branch so please check the full list at: https://docs.sqlalchemy.org/en/14/changelog/changelog_14.html * obsoletes sqlalchemy-7293b3dc0e9eb3dae84ffd831494b85355df8e73.patch in older dists - Update to the 1.4 branch: Version 1.4 is taking on a different focus than other SQLAlchemy releases in that it is in many ways attempting to serve as a potential migration point for a more dramatic series of API changes currently planned for release 2.0 of SQLAlchemy. * Python 3.6 is the minimum Python 3 version; Python 2.7 still supported * ORM Query is internally unified with select, update, delete; 2.0 style execution available. * Transparent SQL Compilation Caching added to All DQL, DML Statements in Core, ORM. * Declarative is now integrated into the ORM with new features * Python Dataclasses, attrs Supported w/ Declarative, Imperative Mappings. * Asynchronous IO Support for Core and ORM * Many Core and ORM statement objects now perform much of their construction and validation in the compile phase * Repaired internal importing conventions such that code linters may work correctly * Support for SQL Regular Expression operators * SQLAlchemy 2.0 Deprecations Mode * API and Behavioral Changes - Core - A SELECT statement is no longer implicitly considered to be a FROM clause - select().join() and outerjoin() add JOIN criteria to the current query, rather than creating a subquery - The URL object is now immutable - Changes to CreateEnginePlugin - select(), case() now accept positional expressions - All IN expressions render parameters for each value in the list on the fly (e.g. expanding parameters) - Built-in FROM linting will warn for any potential cartesian products in a SELECT statement - New Result object - RowProxy is no longer a “proxy”; is now called Row and behaves like an enhanced named tuple - Rationale: To behave more like a named tuple rather than a mapping - Proxying behavior goes away, was also unnecessary in modern usage - SELECT objects and derived FROM clauses allow for duplicate columns and column labels - Improved column labeling for simple column expressions using CAST or similar - New "post compile" bound parameters used for LIMIT/OFFSET in Oracle, SQL Server - Connection-level transactions can now be inactive based on subtransaction - Enum and Boolean datatypes no longer default to "create constraint" * New Features - ORM - Raiseload for Columns - ORM Batch inserts with psycopg2 now batch statements with RETURNING in most cases - ORM Bulk Update and Delete use RETURNING for "fetch" strategy when available * Behavioral Changes - ORM - The "KeyedTuple" object returned by Query is replaced by Row - Session features new “autobegin” behavior - Viewonly relationships don’t synchronize backrefs - cascade_backrefs behavior deprecated for removal in 2.0 - Eager loaders emit during unexpire operations - Accessing an uninitialized collection attribute on a transient object no longer mutates __dict__ - The "New instance conflicts with existing identity" error is now a warning - Persistence-related cascade operations disallowed with viewonly=True - Stricter behavior when querying inheritance mappings using custom queries * Dialect Changes - psycopg2 version 2.7 or higher is required for the PostgreSQL psycopg2 dialect - psycopg2 dialect no longer has limitations regarding bound parameter names - psycopg2 dialect features "execute_values" with RETURNING for INSERT statements by default - Removed “join rewriting” logic from SQLite dialect; updated imports - Added Sequence support for MariaDB 10.3 - Added Sequence support distinct from IDENTITY to SQL Server * For an explanation of each of those changes, check - https://docs.sqlalchemy.org/en/14/changelog/migration_14.html - For the full list of changes in each revision in the 1.4 branch please read: * https://docs.sqlalchemy.org/en/14/changelog/changelog_14.html - Do not build the python2 flavor. Python 2.7 is supposed to be supported but currently fails to build. - Rebase patch: * tests_overcome_bpo42967.patch * Tue Feb 23 2021 Matej Cepl <mcepl@suse.com> - Add tests_overcome_bpo42967.patch to over effects of bpo#42967, which forbade mixing amps and semicolons in query strings as separators (gh#sqlalchemy/sqlalchemy#5969). * Tue Feb 23 2021 Dirk Müller <dmueller@suse.com> - update to 1.3.23: * Release 1.3.23 contains an array of bugfixes specific to dialects such as Oracle, PostgreSQL, and MySQL. * Wed Jan 20 2021 John Vandenberg <jayvdb@gmail.com> - Skip one failing test on Python 3.6
/usr/lib/python3.10/site-packages/SQLAlchemy-2.0.36.dist-info /usr/lib/python3.10/site-packages/SQLAlchemy-2.0.36.dist-info/INSTALLER /usr/lib/python3.10/site-packages/SQLAlchemy-2.0.36.dist-info/LICENSE /usr/lib/python3.10/site-packages/SQLAlchemy-2.0.36.dist-info/METADATA /usr/lib/python3.10/site-packages/SQLAlchemy-2.0.36.dist-info/RECORD /usr/lib/python3.10/site-packages/SQLAlchemy-2.0.36.dist-info/REQUESTED /usr/lib/python3.10/site-packages/SQLAlchemy-2.0.36.dist-info/WHEEL /usr/lib/python3.10/site-packages/SQLAlchemy-2.0.36.dist-info/top_level.txt /usr/lib/python3.10/site-packages/sqlalchemy /usr/lib/python3.10/site-packages/sqlalchemy/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/events.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/events.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/exc.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/exc.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/inspection.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/inspection.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/log.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/log.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/schema.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/schema.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/types.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/__pycache__/types.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__/aioodbc.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__/aioodbc.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__/asyncio.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__/asyncio.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__/pyodbc.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors/__pycache__/pyodbc.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/connectors/aioodbc.py /usr/lib/python3.10/site-packages/sqlalchemy/connectors/asyncio.py /usr/lib/python3.10/site-packages/sqlalchemy/connectors/pyodbc.py /usr/lib/python3.10/site-packages/sqlalchemy/cyextension /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/collections.cpython-310-arm-linux-gnueabihf.so /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/collections.pyx /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/immutabledict.cpython-310-arm-linux-gnueabihf.so /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/immutabledict.pxd /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/immutabledict.pyx /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/processors.cpython-310-arm-linux-gnueabihf.so /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/processors.pyx /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/resultproxy.cpython-310-arm-linux-gnueabihf.so /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/resultproxy.pyx /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/util.cpython-310-arm-linux-gnueabihf.so /usr/lib/python3.10/site-packages/sqlalchemy/cyextension/util.pyx /usr/lib/python3.10/site-packages/sqlalchemy/dialects /usr/lib/python3.10/site-packages/sqlalchemy/dialects/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/dialects/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/__pycache__/_typing.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/__pycache__/_typing.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/_typing.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/aioodbc.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/aioodbc.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/information_schema.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/information_schema.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/json.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/json.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/provision.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/provision.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/pymssql.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/pymssql.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/pyodbc.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/__pycache__/pyodbc.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/aioodbc.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/base.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/information_schema.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/json.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/provision.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/pymssql.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mssql/pyodbc.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/aiomysql.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/aiomysql.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/asyncmy.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/asyncmy.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/cymysql.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/cymysql.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/dml.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/dml.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/enumerated.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/enumerated.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/expression.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/expression.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/json.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/json.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/mariadb.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/mariadb.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/mariadbconnector.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/mariadbconnector.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/mysqlconnector.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/mysqlconnector.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/mysqldb.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/mysqldb.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/provision.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/provision.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/pymysql.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/pymysql.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/pyodbc.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/pyodbc.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/reflection.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/reflection.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/reserved_words.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/reserved_words.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/types.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/__pycache__/types.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/aiomysql.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/asyncmy.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/base.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/cymysql.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/dml.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/enumerated.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/expression.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/json.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/mariadb.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/mariadbconnector.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/mysqlconnector.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/mysqldb.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/provision.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/pymysql.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/pyodbc.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/reflection.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/reserved_words.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/mysql/types.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/cx_oracle.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/cx_oracle.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/dictionary.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/dictionary.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/oracledb.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/oracledb.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/provision.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/provision.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/types.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/__pycache__/types.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/base.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/cx_oracle.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/dictionary.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/oracledb.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/provision.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/oracle/types.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/_psycopg_common.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/_psycopg_common.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/array.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/array.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/asyncpg.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/asyncpg.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/dml.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/dml.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/ext.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/ext.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/hstore.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/hstore.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/json.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/json.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/named_types.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/named_types.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/operators.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/operators.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pg8000.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pg8000.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pg_catalog.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pg_catalog.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/provision.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/provision.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg2.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg2.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg2cffi.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg2cffi.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/ranges.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/ranges.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/types.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/__pycache__/types.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/_psycopg_common.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/array.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/asyncpg.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/base.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/dml.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/ext.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/hstore.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/json.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/named_types.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/operators.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/pg8000.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/pg_catalog.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/provision.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/psycopg.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/psycopg2.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/psycopg2cffi.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/ranges.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/types.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/aiosqlite.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/aiosqlite.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/dml.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/dml.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/json.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/json.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/provision.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/provision.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/pysqlcipher.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/pysqlcipher.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/pysqlite.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/__pycache__/pysqlite.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/aiosqlite.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/base.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/dml.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/json.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/provision.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/pysqlcipher.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/sqlite/pysqlite.py /usr/lib/python3.10/site-packages/sqlalchemy/dialects/type_migration_guidelines.txt /usr/lib/python3.10/site-packages/sqlalchemy/engine /usr/lib/python3.10/site-packages/sqlalchemy/engine/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/_py_processors.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/_py_processors.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/_py_row.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/_py_row.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/_py_util.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/_py_util.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/characteristics.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/characteristics.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/create.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/create.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/cursor.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/cursor.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/default.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/default.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/events.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/events.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/interfaces.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/interfaces.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/mock.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/mock.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/processors.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/processors.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/reflection.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/reflection.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/result.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/result.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/row.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/row.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/strategies.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/strategies.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/url.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/url.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/util.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/__pycache__/util.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/engine/_py_processors.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/_py_row.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/_py_util.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/base.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/characteristics.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/create.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/cursor.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/default.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/events.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/interfaces.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/mock.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/processors.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/reflection.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/result.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/row.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/strategies.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/url.py /usr/lib/python3.10/site-packages/sqlalchemy/engine/util.py /usr/lib/python3.10/site-packages/sqlalchemy/event /usr/lib/python3.10/site-packages/sqlalchemy/event/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/api.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/api.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/attr.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/attr.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/legacy.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/legacy.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/registry.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/__pycache__/registry.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/event/api.py /usr/lib/python3.10/site-packages/sqlalchemy/event/attr.py /usr/lib/python3.10/site-packages/sqlalchemy/event/base.py /usr/lib/python3.10/site-packages/sqlalchemy/event/legacy.py /usr/lib/python3.10/site-packages/sqlalchemy/event/registry.py /usr/lib/python3.10/site-packages/sqlalchemy/events.py /usr/lib/python3.10/site-packages/sqlalchemy/exc.py /usr/lib/python3.10/site-packages/sqlalchemy/ext /usr/lib/python3.10/site-packages/sqlalchemy/ext/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/associationproxy.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/associationproxy.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/automap.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/automap.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/baked.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/baked.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/compiler.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/compiler.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/horizontal_shard.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/horizontal_shard.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/hybrid.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/hybrid.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/indexable.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/indexable.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/instrumentation.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/instrumentation.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/mutable.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/mutable.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/orderinglist.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/orderinglist.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/serializer.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/__pycache__/serializer.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/associationproxy.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/engine.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/engine.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/exc.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/exc.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/result.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/result.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/scoping.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/scoping.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/session.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/__pycache__/session.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/base.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/engine.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/exc.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/result.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/scoping.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/asyncio/session.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/automap.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/baked.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/compiler.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/declarative /usr/lib/python3.10/site-packages/sqlalchemy/ext/declarative/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/declarative/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/ext/declarative/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/declarative/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/declarative/__pycache__/extensions.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/declarative/__pycache__/extensions.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/declarative/extensions.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/horizontal_shard.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/hybrid.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/indexable.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/instrumentation.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/mutable.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/apply.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/apply.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/decl_class.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/decl_class.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/infer.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/infer.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/names.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/names.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/plugin.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/plugin.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/util.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/__pycache__/util.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/apply.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/decl_class.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/infer.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/names.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/plugin.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/mypy/util.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/orderinglist.py /usr/lib/python3.10/site-packages/sqlalchemy/ext/serializer.py /usr/lib/python3.10/site-packages/sqlalchemy/future /usr/lib/python3.10/site-packages/sqlalchemy/future/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/future/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/future/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/future/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/future/__pycache__/engine.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/future/__pycache__/engine.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/future/engine.py /usr/lib/python3.10/site-packages/sqlalchemy/inspection.py /usr/lib/python3.10/site-packages/sqlalchemy/log.py /usr/lib/python3.10/site-packages/sqlalchemy/orm /usr/lib/python3.10/site-packages/sqlalchemy/orm/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/_orm_constructors.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/_orm_constructors.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/_typing.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/_typing.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/attributes.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/attributes.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/bulk_persistence.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/bulk_persistence.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/clsregistry.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/clsregistry.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/collections.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/collections.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/context.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/context.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/decl_api.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/decl_api.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/decl_base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/decl_base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/dependency.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/dependency.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/descriptor_props.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/descriptor_props.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/dynamic.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/dynamic.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/evaluator.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/evaluator.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/events.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/events.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/exc.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/exc.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/identity.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/identity.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/instrumentation.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/instrumentation.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/interfaces.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/interfaces.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/loading.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/loading.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/mapped_collection.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/mapped_collection.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/mapper.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/mapper.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/path_registry.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/path_registry.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/persistence.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/persistence.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/properties.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/properties.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/query.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/query.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/relationships.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/relationships.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/scoping.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/scoping.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/session.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/session.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/state.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/state.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/state_changes.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/state_changes.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/strategies.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/strategies.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/strategy_options.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/strategy_options.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/sync.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/sync.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/unitofwork.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/unitofwork.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/util.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/util.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/writeonly.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/__pycache__/writeonly.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/orm/_orm_constructors.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/_typing.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/attributes.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/base.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/bulk_persistence.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/clsregistry.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/collections.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/context.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/decl_api.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/decl_base.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/dependency.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/descriptor_props.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/dynamic.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/evaluator.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/events.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/exc.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/identity.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/instrumentation.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/interfaces.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/loading.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/mapped_collection.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/mapper.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/path_registry.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/persistence.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/properties.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/query.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/relationships.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/scoping.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/session.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/state.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/state_changes.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/strategies.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/strategy_options.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/sync.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/unitofwork.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/util.py /usr/lib/python3.10/site-packages/sqlalchemy/orm/writeonly.py /usr/lib/python3.10/site-packages/sqlalchemy/pool /usr/lib/python3.10/site-packages/sqlalchemy/pool/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__/events.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__/events.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__/impl.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/pool/__pycache__/impl.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/pool/base.py /usr/lib/python3.10/site-packages/sqlalchemy/pool/events.py /usr/lib/python3.10/site-packages/sqlalchemy/pool/impl.py /usr/lib/python3.10/site-packages/sqlalchemy/py.typed /usr/lib/python3.10/site-packages/sqlalchemy/schema.py /usr/lib/python3.10/site-packages/sqlalchemy/sql /usr/lib/python3.10/site-packages/sqlalchemy/sql/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_dml_constructors.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_dml_constructors.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_elements_constructors.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_elements_constructors.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_orm_types.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_orm_types.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_py_util.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_py_util.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_selectable_constructors.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_selectable_constructors.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_typing.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/_typing.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/annotation.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/annotation.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/cache_key.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/cache_key.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/coercions.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/coercions.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/compiler.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/compiler.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/crud.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/crud.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/ddl.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/ddl.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/default_comparator.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/default_comparator.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/dml.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/dml.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/elements.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/elements.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/events.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/events.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/expression.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/expression.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/functions.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/functions.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/lambdas.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/lambdas.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/naming.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/naming.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/operators.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/operators.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/roles.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/roles.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/schema.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/schema.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/selectable.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/selectable.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/sqltypes.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/sqltypes.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/traversals.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/traversals.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/type_api.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/type_api.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/util.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/util.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/visitors.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/__pycache__/visitors.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/sql/_dml_constructors.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/_elements_constructors.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/_orm_types.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/_py_util.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/_selectable_constructors.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/_typing.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/annotation.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/base.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/cache_key.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/coercions.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/compiler.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/crud.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/ddl.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/default_comparator.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/dml.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/elements.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/events.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/expression.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/functions.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/lambdas.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/naming.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/operators.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/roles.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/schema.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/selectable.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/sqltypes.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/traversals.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/type_api.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/util.py /usr/lib/python3.10/site-packages/sqlalchemy/sql/visitors.py /usr/lib/python3.10/site-packages/sqlalchemy/testing /usr/lib/python3.10/site-packages/sqlalchemy/testing/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/assertions.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/assertions.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/assertsql.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/assertsql.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/asyncio.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/asyncio.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/config.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/config.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/engines.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/engines.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/entities.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/entities.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/exclusions.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/exclusions.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/pickleable.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/pickleable.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/profiling.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/profiling.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/provision.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/provision.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/requirements.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/requirements.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/schema.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/schema.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/util.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/util.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/warnings.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/__pycache__/warnings.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/assertions.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/assertsql.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/asyncio.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/config.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/engines.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/entities.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/exclusions.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/mypy.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/mypy.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/orm.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/orm.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/sql.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/__pycache__/sql.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/base.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/mypy.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/orm.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/fixtures/sql.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/pickleable.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__/bootstrap.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__/bootstrap.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__/plugin_base.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__/plugin_base.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__/pytestplugin.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/__pycache__/pytestplugin.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/bootstrap.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/plugin_base.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/plugin/pytestplugin.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/profiling.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/provision.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/requirements.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/schema.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_cte.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_cte.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_ddl.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_ddl.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_deprecations.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_deprecations.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_dialect.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_dialect.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_insert.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_insert.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_reflection.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_reflection.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_results.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_results.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_rowcount.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_rowcount.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_select.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_select.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_sequence.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_sequence.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_types.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_types.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_unicode_ddl.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_unicode_ddl.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_update_delete.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/__pycache__/test_update_delete.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_cte.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_ddl.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_deprecations.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_dialect.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_insert.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_reflection.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_results.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_rowcount.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_select.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_sequence.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_types.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_unicode_ddl.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/suite/test_update_delete.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/util.py /usr/lib/python3.10/site-packages/sqlalchemy/testing/warnings.py /usr/lib/python3.10/site-packages/sqlalchemy/types.py /usr/lib/python3.10/site-packages/sqlalchemy/util /usr/lib/python3.10/site-packages/sqlalchemy/util/__init__.py /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__ /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/__init__.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/__init__.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/_collections.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/_collections.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/_concurrency_py3k.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/_concurrency_py3k.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/_has_cy.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/_has_cy.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/_py_collections.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/_py_collections.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/compat.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/compat.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/concurrency.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/concurrency.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/deprecations.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/deprecations.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/langhelpers.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/langhelpers.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/preloaded.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/preloaded.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/queue.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/queue.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/tool_support.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/tool_support.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/topological.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/topological.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/typing.cpython-310.opt-1.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/__pycache__/typing.cpython-310.pyc /usr/lib/python3.10/site-packages/sqlalchemy/util/_collections.py /usr/lib/python3.10/site-packages/sqlalchemy/util/_concurrency_py3k.py /usr/lib/python3.10/site-packages/sqlalchemy/util/_has_cy.py /usr/lib/python3.10/site-packages/sqlalchemy/util/_py_collections.py /usr/lib/python3.10/site-packages/sqlalchemy/util/compat.py /usr/lib/python3.10/site-packages/sqlalchemy/util/concurrency.py /usr/lib/python3.10/site-packages/sqlalchemy/util/deprecations.py /usr/lib/python3.10/site-packages/sqlalchemy/util/langhelpers.py /usr/lib/python3.10/site-packages/sqlalchemy/util/preloaded.py /usr/lib/python3.10/site-packages/sqlalchemy/util/queue.py /usr/lib/python3.10/site-packages/sqlalchemy/util/tool_support.py /usr/lib/python3.10/site-packages/sqlalchemy/util/topological.py /usr/lib/python3.10/site-packages/sqlalchemy/util/typing.py /usr/share/doc/packages/python310-SQLAlchemy /usr/share/doc/packages/python310-SQLAlchemy/CHANGES.rst /usr/share/doc/packages/python310-SQLAlchemy/README.dialects.rst /usr/share/doc/packages/python310-SQLAlchemy/README.rst /usr/share/doc/packages/python310-SQLAlchemy/README.unittests.rst /usr/share/licenses/python310-SQLAlchemy /usr/share/licenses/python310-SQLAlchemy/LICENSE
Generated by rpm2html 1.8.1
Fabrice Bellet, Sat Nov 16 01:07:39 2024