python311-SQLAlchemy1-1.4.54-1.3 RPM for armv7hl

From OpenSuSE Ports Tumbleweed for armv7hl

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.

Provides

• python311-SQLAlchemy1
• python3-SQLAlchemy
• python3-SQLAlchemy1
• python3-sqlalchemy
• python3.11dist(sqlalchemy)
• python311-SQLAlchemy
• python311-SQLAlchemy1(armv7hl-32)
• python311-sqlalchemy
• python3dist(sqlalchemy)

Requires

• ld-linux-armhf.so.3
• ld-linux-armhf.so.3(GLIBC_2.4)
• libc.so.6
• libc.so.6(GLIBC_2.38)
• libc.so.6(GLIBC_2.4)
• libgcc_s.so.1
• libgcc_s.so.1(GCC_3.5)
• python(abi) = 3.11
• python311
• python311-greenlet
• rpmlib(CompressedFileNames) <= 3.0.4-1
• rpmlib(FileDigests) <= 4.6.0-1
• rpmlib(PartialHardlinkSets) <= 4.0.4-1
• rpmlib(PayloadFilesHavePrefix) <= 4.0-1
• rpmlib(PayloadIsZstd) <= 5.4.18-1

License

MIT

Changelog

* Thu Sep 19 2024 Steve Kowalik <steven.kowalik@suse.com>
  - Update to 1.4.54:
    * Fixed regression from 1.3 where the column key used for a hybrid property
      might be populated with that of the underlying column that it returns.
    * The pin for ``setuptools<69.3`` in ``pyproject.toml`` has been removed.
    * Set up full Python 3.13 support to the extent currently possible, repairing
      issues within internal language helpers as well as the serializer extension
      module.
    * Adjustments to the C extensions, which are specific to the SQLAlchemy 1.x
      series, to work under Python 3.13.
    * Fixed regression going back to 1.4 where accessing a collection using the
      "dynamic" strategy on a transient object and attempting to query would
      raise an internal error.
    * Fixed bug where ORM :func:`_orm.with_loader_criteria` would not apply
      itself to a :meth:`_sql.Select.join` where the ON clause were given as a
      plain SQL comparison, rather than as a relationship target or similar.
    * Fixed regression introduced by the fix when using pool pre-ping with
      PyMySQL version older than 1.0.
    * Fixed critical issue in asyncio version of the connection pool where
      calling :meth:`_asyncio.AsyncEngine.dispose` would produce a new connection
      pool that did not fully re-establish the use of asyncio-compatible mutexes
    * Fixed fundamental issue which prevented some forms of ORM "annotations"
      from taking place for subqueries which made use of :meth:`_sql.Select.join`
      against a relationship target
    * Repaired a new incompatibility in the MySQL "pre-ping" routine where the
      ``False`` argument passed to ``connection.ping()``, which is intended to
      disable an unwanted "automatic reconnect" feature
  - Switch to pyproject macros.
* Mon Sep 25 2023 Ondřej Súkup <mimi.vx@gmail.com>
  - update to 1.4.49
    * support for python3.12
    * see https://docs.sqlalchemy.org/en/20/changelog/changelog_14.html#change-1.4.49
* Tue May 09 2023 Dominique Leuenberger <dimstar@opensuse.org>
  - Properly advertise this package also as python-SQLAlchemy.
* Sat May 06 2023 Dirk Müller <dmueller@suse.com>
  - remove parallel testing, too unstable
  - readd provides which is needed to select between 1.x and 2.x
* Thu May 04 2023 Dirk Müller <dmueller@suse.com>
  - rename to SQLAlchemy1
* 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]

Files

/usr/lib/python3.11/site-packages/SQLAlchemy-1.4.54.dist-info
/usr/lib/python3.11/site-packages/SQLAlchemy-1.4.54.dist-info/INSTALLER
/usr/lib/python3.11/site-packages/SQLAlchemy-1.4.54.dist-info/LICENSE
/usr/lib/python3.11/site-packages/SQLAlchemy-1.4.54.dist-info/METADATA
/usr/lib/python3.11/site-packages/SQLAlchemy-1.4.54.dist-info/RECORD
/usr/lib/python3.11/site-packages/SQLAlchemy-1.4.54.dist-info/REQUESTED
/usr/lib/python3.11/site-packages/SQLAlchemy-1.4.54.dist-info/WHEEL
/usr/lib/python3.11/site-packages/SQLAlchemy-1.4.54.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__/processors.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/__pycache__/processors.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/cimmutabledict.cpython-311-arm-linux-gnueabihf.so
/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__/mxodbc.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/connectors/__pycache__/mxodbc.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/mxodbc.py
/usr/lib/python3.11/site-packages/sqlalchemy/connectors/pyodbc.py
/usr/lib/python3.11/site-packages/sqlalchemy/cprocessors.cpython-311-arm-linux-gnueabihf.so
/usr/lib/python3.11/site-packages/sqlalchemy/cresultproxy.cpython-311-arm-linux-gnueabihf.so
/usr/lib/python3.11/site-packages/sqlalchemy/databases
/usr/lib/python3.11/site-packages/sqlalchemy/databases/__init__.py
/usr/lib/python3.11/site-packages/sqlalchemy/databases/__pycache__
/usr/lib/python3.11/site-packages/sqlalchemy/databases/__pycache__/__init__.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/databases/__pycache__/__init__.cpython-311.pyc
/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/firebird
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__init__.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__/__init__.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__/__init__.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__/base.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__/base.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__/fdb.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__/fdb.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__/kinterbasdb.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/__pycache__/kinterbasdb.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/base.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/fdb.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/firebird/kinterbasdb.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__/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__/mxodbc.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/mssql/__pycache__/mxodbc.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/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/mxodbc.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__/oursql.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/mysql/__pycache__/oursql.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/oursql.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__/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/base.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/cx_oracle.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/oracle/provision.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__/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__/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__/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__/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__/pygresql.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pygresql.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pypostgresql.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/__pycache__/pypostgresql.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/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/pg8000.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/provision.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/pygresql.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/pypostgresql.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/postgresql/ranges.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/sybase
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__init__.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/__init__.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/__init__.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/base.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/base.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/mxodbc.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/mxodbc.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/pyodbc.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/pyodbc.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/pysybase.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/__pycache__/pysybase.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/base.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/mxodbc.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/pyodbc.py
/usr/lib/python3.11/site-packages/sqlalchemy/dialects/sybase/pysybase.py
/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__/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__/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/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/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__/events.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/ext/asyncio/__pycache__/events.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/events.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/future/orm
/usr/lib/python3.11/site-packages/sqlalchemy/future/orm/__init__.py
/usr/lib/python3.11/site-packages/sqlalchemy/future/orm/__pycache__
/usr/lib/python3.11/site-packages/sqlalchemy/future/orm/__pycache__/__init__.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/future/orm/__pycache__/__init__.cpython-311.pyc
/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__/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__/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__/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__/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/attributes.py
/usr/lib/python3.11/site-packages/sqlalchemy/orm/base.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/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/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/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__/dbapi_proxy.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/pool/__pycache__/dbapi_proxy.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/dbapi_proxy.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/processors.py
/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__/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__/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/annotation.py
/usr/lib/python3.11/site-packages/sqlalchemy/sql/base.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__/fixtures.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/fixtures.cpython-311.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/mock.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/testing/__pycache__/mock.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.py
/usr/lib/python3.11/site-packages/sqlalchemy/testing/mock.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/__pycache__/reinvent_fixtures_py2k.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/testing/plugin/__pycache__/reinvent_fixtures_py2k.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/plugin/reinvent_fixtures_py2k.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__/_compat_py3k.cpython-311.opt-1.pyc
/usr/lib/python3.11/site-packages/sqlalchemy/util/__pycache__/_compat_py3k.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__/_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__/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__/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/_collections.py
/usr/lib/python3.11/site-packages/sqlalchemy/util/_compat_py3k.py
/usr/lib/python3.11/site-packages/sqlalchemy/util/_concurrency_py3k.py
/usr/lib/python3.11/site-packages/sqlalchemy/util/_preloaded.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/queue.py
/usr/lib/python3.11/site-packages/sqlalchemy/util/tool_support.py
/usr/lib/python3.11/site-packages/sqlalchemy/util/topological.py
/usr/share/doc/packages/python311-SQLAlchemy1
/usr/share/doc/packages/python311-SQLAlchemy1/CHANGES
/usr/share/doc/packages/python311-SQLAlchemy1/README.dialects.rst
/usr/share/doc/packages/python311-SQLAlchemy1/README.rst
/usr/share/doc/packages/python311-SQLAlchemy1/README.unittests.rst
/usr/share/licenses/python311-SQLAlchemy1
/usr/share/licenses/python311-SQLAlchemy1/LICENSE

Generated by rpm2html 1.8.1

Fabrice Bellet, Sat Feb 1 00:19:49 2025