| Index | index by Group | index by Distribution | index by Vendor | index by creation date | index by Name | Mirrors | Help | Search |
| Name: python311-SQLAlchemy | Distribution: openSUSE Tumbleweed |
| Version: 2.0.36 | Vendor: openSUSE |
| Release: 1.2 | Build date: Wed Nov 6 15:43:11 2024 |
| Group: Unspecified | Build host: reproducible |
| Size: 24790667 | Source RPM: python-SQLAlchemy-2.0.36-1.2.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.11/site-packages/SQLAlchemy-2.0.36.dist-info /usr/lib/python3.11/site-packages/SQLAlchemy-2.0.36.dist-info/INSTALLER /usr/lib/python3.11/site-packages/SQLAlchemy-2.0.36.dist-info/LICENSE /usr/lib/python3.11/site-packages/SQLAlchemy-2.0.36.dist-info/METADATA /usr/lib/python3.11/site-packages/SQLAlchemy-2.0.36.dist-info/RECORD /usr/lib/python3.11/site-packages/SQLAlchemy-2.0.36.dist-info/REQUESTED /usr/lib/python3.11/site-packages/SQLAlchemy-2.0.36.dist-info/WHEEL /usr/lib/python3.11/site-packages/SQLAlchemy-2.0.36.dist-info/top_level.txt /usr/lib/python3.11/site-packages/sqlalchemy /usr/lib/python3.11/site-packages/sqlalchemy/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/events.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/events.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/exc.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/exc.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/inspection.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/inspection.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/log.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/log.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/schema.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/schema.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/types.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/types.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/aioodbc.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/aioodbc.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/asyncio.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/asyncio.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/pyodbc.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/pyodbc.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/connectors/aioodbc.py /usr/lib/python3.11/site-packages/sqlalchemy/connectors/asyncio.py /usr/lib/python3.11/site-packages/sqlalchemy/connectors/pyodbc.py /usr/lib/python3.11/site-packages/sqlalchemy/cyextension /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/collections.cpython-311-i386-linux-gnu.so /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/collections.pyx /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/immutabledict.cpython-311-i386-linux-gnu.so /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/immutabledict.pxd /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/immutabledict.pyx /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/processors.cpython-311-i386-linux-gnu.so /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/processors.pyx /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/resultproxy.cpython-311-i386-linux-gnu.so /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/resultproxy.pyx /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/util.cpython-311-i386-linux-gnu.so /usr/lib/python3.11/site-packages/sqlalchemy/cyextension/util.pyx /usr/lib/python3.11/site-packages/sqlalchemy/dialects /usr/lib/python3.11/site-packages/sqlalchemy/dialects/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/dialects/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/__pycache__/_typing.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/__pycache__/_typing.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/_typing.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/aioodbc.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/aioodbc.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/information_schema.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/information_schema.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/json.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/json.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/provision.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/provision.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/pymssql.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/pymssql.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/pyodbc.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/pyodbc.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/aioodbc.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/base.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/information_schema.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/json.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/provision.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/pymssql.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/pyodbc.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/aiomysql.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/aiomysql.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/asyncmy.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/asyncmy.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/cymysql.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/cymysql.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/dml.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/dml.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/enumerated.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/enumerated.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/expression.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/expression.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/json.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/json.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/mariadb.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/mariadb.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/mariadbconnector.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/mariadbconnector.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/mysqlconnector.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/mysqlconnector.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/mysqldb.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/mysqldb.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/provision.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/provision.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/pymysql.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/pymysql.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/pyodbc.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/pyodbc.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/reflection.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/reflection.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/reserved_words.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/reserved_words.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/types.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/types.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/aiomysql.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/asyncmy.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/base.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/cymysql.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/dml.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/enumerated.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/expression.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/json.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/mariadb.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/mariadbconnector.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/mysqlconnector.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/mysqldb.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/provision.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/pymysql.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/pyodbc.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/reflection.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/reserved_words.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/types.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/cx_oracle.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/cx_oracle.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/dictionary.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/dictionary.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/oracledb.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/oracledb.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/provision.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/provision.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/types.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/__pycache__/types.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/base.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/cx_oracle.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/dictionary.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/oracledb.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/provision.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/types.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/_psycopg_common.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/_psycopg_common.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/array.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/array.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/asyncpg.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/asyncpg.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/dml.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/dml.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/ext.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/ext.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/hstore.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/hstore.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/json.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/json.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/named_types.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/named_types.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/operators.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/operators.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pg8000.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pg8000.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pg_catalog.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pg_catalog.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/provision.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/provision.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg2.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg2.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg2cffi.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/psycopg2cffi.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/ranges.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/ranges.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/types.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/types.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/_psycopg_common.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/array.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/asyncpg.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/base.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/dml.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/ext.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/hstore.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/json.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/named_types.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/operators.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/pg8000.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/pg_catalog.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/provision.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/psycopg.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/psycopg2.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/psycopg2cffi.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/ranges.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/types.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/aiosqlite.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/aiosqlite.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/dml.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/dml.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/json.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/json.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/provision.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/provision.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/pysqlcipher.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/pysqlcipher.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/pysqlite.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/__pycache__/pysqlite.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/aiosqlite.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/base.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/dml.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/json.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/provision.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/pysqlcipher.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/sqlite/pysqlite.py /usr/lib/python3.11/site-packages/sqlalchemy/dialects/type_migration_guidelines.txt /usr/lib/python3.11/site-packages/sqlalchemy/engine /usr/lib/python3.11/site-packages/sqlalchemy/engine/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/_py_processors.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/_py_processors.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/_py_row.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/_py_row.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/_py_util.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/_py_util.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/characteristics.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/characteristics.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/create.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/create.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/cursor.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/cursor.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/default.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/default.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/events.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/events.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/interfaces.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/interfaces.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/mock.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/mock.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/processors.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/processors.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/reflection.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/reflection.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/result.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/result.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/row.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/row.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/strategies.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/strategies.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/url.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/url.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/util.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/__pycache__/util.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/engine/_py_processors.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/_py_row.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/_py_util.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/base.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/characteristics.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/create.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/cursor.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/default.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/events.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/interfaces.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/mock.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/processors.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/reflection.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/result.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/row.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/strategies.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/url.py /usr/lib/python3.11/site-packages/sqlalchemy/engine/util.py /usr/lib/python3.11/site-packages/sqlalchemy/event /usr/lib/python3.11/site-packages/sqlalchemy/event/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/api.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/api.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/attr.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/attr.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/legacy.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/legacy.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/registry.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/__pycache__/registry.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/event/api.py /usr/lib/python3.11/site-packages/sqlalchemy/event/attr.py /usr/lib/python3.11/site-packages/sqlalchemy/event/base.py /usr/lib/python3.11/site-packages/sqlalchemy/event/legacy.py /usr/lib/python3.11/site-packages/sqlalchemy/event/registry.py /usr/lib/python3.11/site-packages/sqlalchemy/events.py /usr/lib/python3.11/site-packages/sqlalchemy/exc.py /usr/lib/python3.11/site-packages/sqlalchemy/ext /usr/lib/python3.11/site-packages/sqlalchemy/ext/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/associationproxy.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/associationproxy.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/automap.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/automap.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/baked.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/baked.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/compiler.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/compiler.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/horizontal_shard.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/horizontal_shard.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/hybrid.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/hybrid.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/indexable.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/indexable.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/instrumentation.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/instrumentation.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/mutable.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/mutable.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/orderinglist.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/orderinglist.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/serializer.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/__pycache__/serializer.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/associationproxy.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/engine.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/engine.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/exc.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/exc.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/result.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/result.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/scoping.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/scoping.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/session.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/session.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/base.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/engine.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/exc.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/result.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/scoping.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/session.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/automap.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/baked.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/compiler.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/declarative /usr/lib/python3.11/site-packages/sqlalchemy/ext/declarative/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/declarative/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/ext/declarative/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/declarative/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/declarative/__pycache__/extensions.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/declarative/__pycache__/extensions.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/declarative/extensions.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/horizontal_shard.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/hybrid.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/indexable.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/instrumentation.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/mutable.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/apply.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/apply.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/decl_class.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/decl_class.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/infer.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/infer.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/names.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/names.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/plugin.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/plugin.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/util.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/__pycache__/util.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/apply.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/decl_class.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/infer.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/names.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/plugin.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/mypy/util.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/orderinglist.py /usr/lib/python3.11/site-packages/sqlalchemy/ext/serializer.py /usr/lib/python3.11/site-packages/sqlalchemy/future /usr/lib/python3.11/site-packages/sqlalchemy/future/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/future/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/future/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/future/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/future/__pycache__/engine.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/future/__pycache__/engine.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/future/engine.py /usr/lib/python3.11/site-packages/sqlalchemy/inspection.py /usr/lib/python3.11/site-packages/sqlalchemy/log.py /usr/lib/python3.11/site-packages/sqlalchemy/orm /usr/lib/python3.11/site-packages/sqlalchemy/orm/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/_orm_constructors.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/_orm_constructors.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/_typing.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/_typing.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/attributes.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/attributes.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/bulk_persistence.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/bulk_persistence.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/clsregistry.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/clsregistry.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/collections.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/collections.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/context.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/context.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/decl_api.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/decl_api.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/decl_base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/decl_base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/dependency.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/dependency.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/descriptor_props.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/descriptor_props.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/dynamic.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/dynamic.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/evaluator.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/evaluator.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/events.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/events.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/exc.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/exc.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/identity.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/identity.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/instrumentation.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/instrumentation.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/interfaces.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/interfaces.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/loading.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/loading.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/mapped_collection.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/mapped_collection.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/mapper.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/mapper.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/path_registry.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/path_registry.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/persistence.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/persistence.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/properties.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/properties.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/query.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/query.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/relationships.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/relationships.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/scoping.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/scoping.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/session.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/session.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/state.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/state.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/state_changes.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/state_changes.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/strategies.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/strategies.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/strategy_options.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/strategy_options.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/sync.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/sync.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/unitofwork.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/unitofwork.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/util.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/util.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/writeonly.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/__pycache__/writeonly.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/orm/_orm_constructors.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/_typing.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/attributes.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/base.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/bulk_persistence.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/clsregistry.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/collections.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/context.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/decl_api.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/decl_base.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/dependency.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/descriptor_props.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/dynamic.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/evaluator.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/events.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/exc.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/identity.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/instrumentation.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/interfaces.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/loading.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/mapped_collection.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/mapper.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/path_registry.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/persistence.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/properties.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/query.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/relationships.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/scoping.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/session.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/state.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/state_changes.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/strategies.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/strategy_options.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/sync.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/unitofwork.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/util.py /usr/lib/python3.11/site-packages/sqlalchemy/orm/writeonly.py /usr/lib/python3.11/site-packages/sqlalchemy/pool /usr/lib/python3.11/site-packages/sqlalchemy/pool/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/events.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/events.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/impl.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/impl.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/pool/base.py /usr/lib/python3.11/site-packages/sqlalchemy/pool/events.py /usr/lib/python3.11/site-packages/sqlalchemy/pool/impl.py /usr/lib/python3.11/site-packages/sqlalchemy/py.typed /usr/lib/python3.11/site-packages/sqlalchemy/schema.py /usr/lib/python3.11/site-packages/sqlalchemy/sql /usr/lib/python3.11/site-packages/sqlalchemy/sql/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_dml_constructors.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_dml_constructors.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_elements_constructors.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_elements_constructors.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_orm_types.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_orm_types.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_py_util.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_py_util.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_selectable_constructors.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_selectable_constructors.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_typing.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/_typing.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/annotation.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/annotation.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/cache_key.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/cache_key.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/coercions.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/coercions.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/compiler.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/compiler.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/crud.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/crud.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/ddl.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/ddl.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/default_comparator.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/default_comparator.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/dml.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/dml.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/elements.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/elements.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/events.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/events.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/expression.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/expression.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/functions.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/functions.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/lambdas.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/lambdas.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/naming.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/naming.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/operators.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/operators.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/roles.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/roles.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/schema.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/schema.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/selectable.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/selectable.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/sqltypes.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/sqltypes.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/traversals.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/traversals.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/type_api.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/type_api.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/util.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/util.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/visitors.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/__pycache__/visitors.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/sql/_dml_constructors.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/_elements_constructors.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/_orm_types.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/_py_util.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/_selectable_constructors.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/_typing.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/annotation.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/base.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/cache_key.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/coercions.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/compiler.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/crud.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/ddl.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/default_comparator.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/dml.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/elements.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/events.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/expression.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/functions.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/lambdas.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/naming.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/operators.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/roles.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/schema.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/selectable.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/sqltypes.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/traversals.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/type_api.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/util.py /usr/lib/python3.11/site-packages/sqlalchemy/sql/visitors.py /usr/lib/python3.11/site-packages/sqlalchemy/testing /usr/lib/python3.11/site-packages/sqlalchemy/testing/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/assertions.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/assertions.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/assertsql.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/assertsql.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/asyncio.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/asyncio.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/config.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/config.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/engines.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/engines.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/entities.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/entities.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/exclusions.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/exclusions.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/pickleable.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/pickleable.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/profiling.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/profiling.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/provision.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/provision.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/requirements.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/requirements.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/schema.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/schema.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/util.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/util.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/warnings.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/warnings.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/assertions.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/assertsql.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/asyncio.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/config.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/engines.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/entities.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/exclusions.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/mypy.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/mypy.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/orm.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/orm.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/sql.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/__pycache__/sql.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/base.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/mypy.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/orm.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/fixtures/sql.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/pickleable.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/bootstrap.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/bootstrap.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/plugin_base.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/plugin_base.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/pytestplugin.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/pytestplugin.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/bootstrap.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/plugin_base.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/pytestplugin.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/profiling.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/provision.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/requirements.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/schema.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_cte.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_cte.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_ddl.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_ddl.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_deprecations.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_deprecations.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_dialect.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_dialect.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_insert.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_insert.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_reflection.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_reflection.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_results.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_results.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_rowcount.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_rowcount.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_select.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_select.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_sequence.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_sequence.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_types.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_types.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_unicode_ddl.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_unicode_ddl.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_update_delete.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/__pycache__/test_update_delete.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_cte.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_ddl.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_deprecations.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_dialect.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_insert.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_reflection.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_results.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_rowcount.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_select.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_sequence.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_types.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_unicode_ddl.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/suite/test_update_delete.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/util.py /usr/lib/python3.11/site-packages/sqlalchemy/testing/warnings.py /usr/lib/python3.11/site-packages/sqlalchemy/types.py /usr/lib/python3.11/site-packages/sqlalchemy/util /usr/lib/python3.11/site-packages/sqlalchemy/util/__init__.py /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__ /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/__init__.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/__init__.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_collections.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_collections.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_concurrency_py3k.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_concurrency_py3k.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_has_cy.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_has_cy.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_py_collections.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_py_collections.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/compat.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/compat.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/concurrency.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/concurrency.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/deprecations.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/deprecations.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/langhelpers.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/langhelpers.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/preloaded.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/preloaded.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/queue.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/queue.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/tool_support.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/tool_support.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/topological.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/topological.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/typing.cpython-311.opt-1.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/typing.cpython-311.pyc /usr/lib/python3.11/site-packages/sqlalchemy/util/_collections.py /usr/lib/python3.11/site-packages/sqlalchemy/util/_concurrency_py3k.py /usr/lib/python3.11/site-packages/sqlalchemy/util/_has_cy.py /usr/lib/python3.11/site-packages/sqlalchemy/util/_py_collections.py /usr/lib/python3.11/site-packages/sqlalchemy/util/compat.py /usr/lib/python3.11/site-packages/sqlalchemy/util/concurrency.py /usr/lib/python3.11/site-packages/sqlalchemy/util/deprecations.py /usr/lib/python3.11/site-packages/sqlalchemy/util/langhelpers.py /usr/lib/python3.11/site-packages/sqlalchemy/util/preloaded.py /usr/lib/python3.11/site-packages/sqlalchemy/util/queue.py /usr/lib/python3.11/site-packages/sqlalchemy/util/tool_support.py /usr/lib/python3.11/site-packages/sqlalchemy/util/topological.py /usr/lib/python3.11/site-packages/sqlalchemy/util/typing.py /usr/share/doc/packages/python311-SQLAlchemy /usr/share/doc/packages/python311-SQLAlchemy/CHANGES.rst /usr/share/doc/packages/python311-SQLAlchemy/README.dialects.rst /usr/share/doc/packages/python311-SQLAlchemy/README.rst /usr/share/doc/packages/python311-SQLAlchemy/README.unittests.rst /usr/share/licenses/python311-SQLAlchemy /usr/share/licenses/python311-SQLAlchemy/LICENSE
Generated by rpm2html 1.8.1
Fabrice Bellet, Wed Dec 25 23:23:28 2024