python2-SQLAlchemy-1.2.14-lp152.4.3.1 RPM for ppc64le

From OpenSuSE Ports Leap 15.2 updates for ppc64le

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

• python2-SQLAlchemy
• python-SQLAlchemy
• python-sqlalchemy
• python2-SQLAlchemy(ppc-64)

Requires

• libc.so.6()(64bit)
• libc.so.6(GLIBC_2.17)(64bit)
• libpthread.so.0()(64bit)
• libpython2.7.so.1.0()(64bit)
• python(abi) = 2.7
• rpmlib(CompressedFileNames) <= 3.0.4-1
• rpmlib(FileDigests) <= 4.6.0-1
• rpmlib(PartialHardlinkSets) <= 4.0.4-1
• rpmlib(PayloadFilesHavePrefix) <= 4.0-1
• rpmlib(PayloadIsXz) <= 5.2-1

License

MIT

Changelog

* Thu Oct 15 2020 Johannes Grassler <johannes.grassler@suse.com>
  - Add 0002-maintain-compiled_params-replacement_expressions.patch
    (bsc#1176953)
    * Maintain compiled_params / replacement_expressions within
      expanding IN
* Tue Aug 20 2019 Ralf Haferkamp <rhafer@suse.com>
  - Add 0001-Illustrate-fix-for-4481-in-terms-of-a-1.2-patch.patch
    (bsc#1124593,  CVE-2019-7164, CVE-2019-7548)
* Mon Nov 12 2018 Arun Persaud <arun@gmx.de>
  - update to version 1.2.14:
    * orm
      + [orm] [bug] Fixed bug in Session.bulk_update_mappings() where
      alternate mapped attribute names would result in the primary key
      column of the UPDATE statement being included in the SET clause,
      as well as the WHERE clause; while usually harmless, for SQL
      Server this can raise an error due to the IDENTITY column. This
      is a continuation of the same bug that was fixed in #3849, where
      testing was insufficient to catch this additional flaw.
      References: #4357
      + [orm] [bug] Fixed a minor performance issue which could in some
      cases add unnecessary overhead to result fetching, involving the
      use of ORM columns and entities that include those same columns
      at the same time within a query. The issue has to do with hash /
      eq overhead when referring to the column in different ways.
      References: #4347
    * mysql
      + [mysql] [bug] Fixed regression caused by #4344 released in
      1.2.13, where the fix for MySQL 8.0’s case sensitivity problem
      with referenced column names when reflecting foreign key
      referents is worked around using the information_schema.columns
      view. The workaround was failing on OSX /
      lower_case_table_names=2 which produces non-matching casing for
      the information_schema.columns vs. that of SHOW CREATE TABLE, so
      in case-insensitive SQL modes case-insensitive matching is now
      used.  References: #4361
* Thu Nov 01 2018 Arun Persaud <arun@gmx.de>
  - update to version 1.2.13:
    * orm
      + [orm] [bug] Fixed bug where “dynamic” loader needs to explicitly
      set the “secondary” table in the FROM clause of the query, to
      suit the case where the secondary is a join object that is
      otherwise not pulled into the query from its columns alone.
      References: #4349
    * orm declarative
      + [bug] [declarative] [orm] Fixed regression caused by #4326 in
      version 1.2.12 where using declared_attr with a mixin in
      conjunction with orm.synonym() would fail to map the synonym
      properly to an inherited subclass.  References: #4350
      + [bug] [declarative] [orm] The column conflict resolution
      technique discussed at Resolving Column Conflicts is now
      functional for a Column that is also a primary key
      column. Previously, a check for primary key columns declared on
      a single-inheritance subclass would occur before the column copy
      were allowed to pass.  References: #4352
    * sql
      + [sql] [feature] Refactored SQLCompiler to expose a
      SQLCompiler.group_by_clause() method similar to the
      SQLCompiler.order_by_clause() and SQLCompiler.limit_clause()
      methods, which can be overridden by dialects to customize how
      GROUP BY renders. Pull request courtesy Samuel Chou.
      + [sql] [bug] Fixed bug where the Enum.create_constraint flag on
      the Enum datatype would not be propagated to copies of the type,
      which affects use cases such as declarative mixins and abstract
      bases.  References: #4341
    * postgresql
      + [postgresql] [bug] Added support for the aggregate_order_by
      function to receive multiple ORDER BY elements, previously only
      a single element was accepted.  References: #4337
    * mysql
      + [mysql] [bug] Added word function to the list of reserved words
      for MySQL, which is now a keyword in MySQL 8.0 References: #4348
      + [mysql] [bug] Added a workaround for a MySQL bug #88718
      introduced in the 8.0 series, where the reflection of a foreign
      key constraint is not reporting the correct case sensitivity for
      the referred column, leading to errors during use of the
      reflected constraint such as when using the automap
      extension. The workaround emits an additional query to the
      information_schema tables in order to retrieve the correct case
      sensitive name.  References: #4344
    * misc
      + [misc] [bug] Fixed issue where part of the utility language
      helper internals was passing the wrong kind of argument to the
      Python __import__ builtin as the list of modules to be
      imported. The issue produced no symptoms within the core library
      but could cause issues with external applications that redefine
      the __import__ builtin or otherwise instrument it. Pull request
      courtesy Joe Urciuoli.
      + [misc] [bug] [py3k] Fixed additional warnings generated by
      Python 3.7 due to changes in the organization of the Python
      collections and collections.abc packages. Previous collections
      warnings were fixed in version 1.2.11. Pull request courtesy
      xtreak.  References: #4339
      + [bug] [ext] Added missing .index() method to list-based
      association collections in the association proxy extension.
* Sat Sep 22 2018 Arun Persaud <arun@gmx.de>
  - update to version 1.2.12:
    * orm
      + [orm] [bug] Added a check within the weakref cleanup for the
      InstanceState object to check for the presence of the dict
      builtin, in an effort to reduce error messages generated when
      these cleanups occur during interpreter shutdown. Pull request
      courtesy Romuald Brunet.
      + [orm] [bug] Fixed bug where use of Lateral construct in
      conjunction with Query.join() as well as
      Query.select_entity_from() would not apply clause adaption to
      the right side of the join. “lateral” introduces the use case of
      the right side of a join being correlatable. Previously,
      adaptation of this clause wasn’t considered. Note that in 1.2
      only, a selectable introduced by Query.subquery() is still not
      adapted due to #4304; the selectable needs to be produced by the
      select() function to be the right side of the “lateral” join.
      References: #4334
      + [orm] [bug] Fixed 1.2 regression caused by #3472 where the
      handling of an “updated_at” style column within the context of a
      post-update operation would also occur for a row that is to be
      deleted following the update, meaning both that a column with a
      Python-side value generator would show the now-deleted value
      that was emitted for the UPDATE before the DELETE (which was not
      the previous behavor), as well as that a SQL- emitted value
      generator would have the attribute expired, meaning the previous
      value would be unreachable due to the row having been deleted
      and the object detached from the session.The “postfetch” logic
      that was added as part of #3472 is now skipped entirely for an
      object that ultimately is to be deleted.  References: #4327
    * orm declarative
      + [bug] [declarative] [orm] Fixed bug where the declarative scan
      for attributes would receive the expression proxy delivered by a
      hybrid attribute at the class level, and not the hybrid
      attribute itself, when receiving the descriptor via the
      @declared_attr callable on a subclass of an already-mapped
      class. This would lead to an attribute that did not report
      itself as a hybrid when viewed within
      Mapper.all_orm_descriptors.  References: #4326
    * postgresql
      + [postgresql] [bug] Fixed bug in PostgreSQL dialect where
      compiler keyword arguments such as literal_binds=True were not
      being propagated to a DISTINCT ON expression.  References: #4325
      + [postgresql] [bug] Fixed the postgresql.array_agg() function,
      which is a slightly altered version of the usual
      functions.array_agg() function, to also accept an incoming
      “type” argument without forcing an ARRAY around it, essentially
      the same thing that was fixed for the generic function in 1.1 in
      [#4107].  References: #4324
      + [postgresql] [bug] Fixed bug in PostgreSQL ENUM reflection where
      a case-sensitive, quoted name would be reported by the query
      including quotes, which would not match a target column during
      table reflection as the quotes needed to be stripped off.
      References: #4323
    * oracle
      + [oracle] [bug] Fixed issue for cx_Oracle 7.0 where the behavior
      of Oracle param.getvalue() now returns a list, rather than a
      single scalar value, breaking autoincrement logic throughout the
      Core and ORM. The dml_ret_array_val compatibility flag is used
      for cx_Oracle 6.3 and 6.4 to establish compatible behavior with
      7.0 and forward, for cx_Oracle 6.2.1 and prior a version number
      check falls back to the old logic.  References: #4335
    * misc
      + [bug] [ext] Fixed issue where BakedQuery did not include the
      specific query class used by the Session as part of the cache
      key, leading to incompatibilities when using custom query
      classes, in particular the ShardedQuery which has some different
      argument signatures.  References: #4328
* Sat Aug 25 2018 arun@gmx.de
  - update to version 1.2.11:
    * orm declarative
      + [bug] [declarative] [orm] Fixed issue in previously untested use
      case, allowing a declarative mapped class to inherit from a
      classically-mapped class outside of the declarative base,
      including that it accommodates for unmapped intermediate
      classes. An unmapped intermediate class may specify
      __abstract__, which is now interpreted correctly, or the
      intermediate class can remain unmarked, and the classically
      mapped base class will be detected within the hierarchy
      regardless. In order to anticipate existing scenarios which may
      be mixing in classical mappings into existing declarative
      hierarchies, an error is now raised if multiple mapped bases are
      detected for a given class.   References: #4321
    * sql
      + [sql] [bug] Fixed issue that is closely related to #3639 where
      an expression rendered in a boolean context on a non-native
      boolean backend would be compared to 1/0 even though it is
      already an implcitly boolean expression, when
      ColumnElement.self_group() were used. While this does not affect
      the user-friendly backends (MySQL, SQLite) it was not handled by
      Oracle (and possibly SQL Server). Whether or not the expression
      is implicitly boolean on any database is now determined up front
      as an additional check to not generate the integer comparison
      within the compliation of the statement.  References: #4320
      + [sql] [bug] Added missing window function parameters
      WithinGroup.over.range_ and WithinGroup.over.rows parameters to
      the WithinGroup.over() and FunctionFilter.over() methods, to
      correspond to the range/rows feature added to the “over” method
      of SQL functions as part of #3049 in version 1.1.  References:
      [#4322]
      + [sql] [bug] Fixed bug where the multi-table support for UPDATE
      and DELETE statements did not consider the additional FROM
      elements as targets for correlation, when a correlated SELECT
      were also combined with the statement. This change now includes
      that a SELECT statement in the WHERE clause for such a statement
      will try to auto-correlate back to these additional tables in
      the parent UPDATE/DELETE or unconditionally correlate if
      Select.correlate() is used. Note that auto-correlation raises an
      error if the SELECT statement would have no FROM clauses as a
      result, which can now occur if the parent UPDATE/DELETE
      specifies the same tables in its additional set of tables;
      specify Select.correlate() explicitly to resolve.  References:
      [#4313]
    * oracle
      + [oracle] [bug] For cx_Oracle, Integer datatypes will now be
      bound to “int”, per advice from the cx_Oracle
      developers. Previously, using cx_Oracle.NUMBER caused a loss in
      precision within the cx_Oracle 6.x series.  References: #4309
    * misc
      + [bug] [py3k] Started importing “collections” from
      “collections.abc” under Python 3.3 and greater for Python 3.8
      compatibility. Pull request courtesy Nathaniel Knight.
      + Fixed issue where the “schema” name used for a SQLite database
      within table reflection would not quote the schema name
      correctly. Pull request courtesy Phillip Cloud.
* Sat Jul 14 2018 arun@gmx.de
  - update to version 1.2.10:
    * orm
      + [orm] [bug] Fixed bug in Bundle construct where placing two
      columns of the same name would be de-duplicated, when the Bundle
      were used as part of the rendered SQL, such as in the ORDER BY
      or GROUP BY of the statement.  References: #4295
      + [orm] [bug] Fixed regression in 1.2.9 due to #4287 where using a
      Load option in conjunction with a string wildcard would result
      in a TypeError.  References: #4298
    * sql
      + [sql] [bug] Fixed bug where a Sequence would be dropped
      explicitly before any Table that refers to it, which breaks in
      the case when the sequence is also involved in a server-side
      default for that table, when using MetaData.drop_all(). The step
      which processes sequences to be dropped via non server-side
      column default functions is now invoked after the table itself
      is dropped.  References: #4300
* Sun Jul 01 2018 arun@gmx.de
  - removed patch fix_test_reflection.patch (included upstream)
  - update to version 1.2.9:
    * orm
      + [orm] [bug] Fixed issue where chaining multiple join elements
      inside of Query.join() might not correctly adapt to the previous
      left-hand side, when chaining joined inheritance classes that
      share the same base class.
      References: #3505
      + [orm] [bug] Fixed bug in cache key generation for baked queries
      which could cause a too-short cache key to be generated for the
      case of eager loads across subclasses. This could in turn cause
      the eagerload query to be cached in place of a non-eagerload
      query, or vice versa, for a polymorhic “selectin” load, or
      possibly for lazy loads or selectin loads as well.
      References: #4287
      + [orm] [bug] Fixed bug in new polymorphic selectin loading where
      the BakedQuery used internally would be mutated by the given
      loader options, which would both inappropriately mutate the
      subclass query as well as carry over the effect to subsequent
      queries.
      References: #4286
      + [orm] [bug] Fixed regression caused by #4256 (itself a
      regression fix for #4228) which breaks an undocumented behavior
      which converted for a non-sequence of entities passed directly
      to the Query constructor into a single-element sequence. While
      this behavior was never supported or documented, it’s already in
      use so has been added as a behavioral contract to Query.
      References: #4269
      + [orm] [bug] Fixed an issue that was both a performance
      regression in 1.2 as well as an incorrect result regarding the
      “baked” lazy loader, involving the generation of cache keys from
      the original Query object’s loader options. If the loader
      options were built up in a “branched” style using common base
      elements for multiple options, the same options would be
      rendered into the cache key repeatedly, causing both a
      performance issue as well as generating the wrong cache
      key. This is fixed, along with a performance improvement when
      such “branched” options are applied via Query.options() to
      prevent the same option objects from being applied repeatedly.
      References: #4270
    * sql
      + [sql] [bug] Fixed regression in 1.2 due to #4147 where a Table
      that has had some of its indexed columns redefined with new
      ones, as would occur when overriding columns during reflection
      or when using Table.extend_existing, such that the
      Table.tometadata() method would fail when attempting to copy
      those indexes as they still referred to the replaced column. The
      copy logic now accommodates for this condition.
      References: #4279
    * mysql
      + [mysql] [bug] Fixed percent-sign doubling in
      mysql-connector-python dialect, which does not require
      de-doubling of percent signs. Additionally, the mysql-
      connector-python driver is inconsistent in how it passes the
      column names in cursor.description, so a workaround decoder has
      been added to conditionally decode these
      randomly-sometimes-bytes values to unicode only if needed. Also
      improved test support for mysql-connector-python, however it
      should be noted that this driver still has issues with unicode
      that continue to be unresolved as of yet.
      + [mysql] [bug] Fixed bug in index reflection where on MySQL 8.0
      an index that includes ASC or DESC in an indexed column
      specfication would not be correctly reflected, as MySQL 8.0
      introduces support for returning this information in a table
      definition string.
      References: #4293
      + [mysql] [bug] Fixed bug in MySQLdb dialect and variants such as
      PyMySQL where an additional “unicode returns” check upon
      connection makes explicit use of the “utf8” character set, which
      in MySQL 8.0 emits a warning that utf8mb4 should be used. This
      is now replaced with a utf8mb4 equivalent. Documentation is also
      updated for the MySQL dialect to specify utf8mb4 in all
      examples. Additional changes have been made to the test suite to
      use utf8mb3 charsets and databases (there seem to be collation
      issues in some edge cases with utf8mb4), and to support
      configuration default changes made in MySQL 8.0 such as
      explicit_defaults_for_timestamp as well as new errors raised for
      invalid MyISAM indexes.
      References: #4283
      + [mysql] [bug] The Update construct now accommodates a Join
      object as supported by MySQL for UPDATE..FROM. As the construct
      already accepted an alias object for a similar purpose, the
      feature of UPDATE against a non-table was already implied so
      this has been added.
      References: #3645
    * sqlite
      + [sqlite] [bug] Fixed issue in test suite where SQLite 3.24 added
      a new reserved word that conflicted with a usage in
      TypeReflectionTest. Pull request courtesy Nils Philippsen.
    * mssql
      + [mssql] [bug] Fixed bug in MSSQL reflection where when two
      same-named tables in different schemas had same-named primary
      key constraints, foreign key constraints referring to one of the
      tables would have their columns doubled, causing errors. Pull
      request courtesy Sean Dunn.
      References: #4228
      + [mssql] [bug] [py3k] Fixed issue within the SQL Server dialect
      under Python 3 where when running against a non-standard SQL
      server database that does not contain either the
      “sys.dm_exec_sessions” or “sys.dm_pdw_nodes_exec_sessions”
      views, leading to a failure to fetch the isolation level, the
      error raise would fail due to an UnboundLocalError.
      References: #4273
    * oracle
      + [oracle] [feature] Added a new event currently used only by the
      cx_Oracle dialect, DialectEvents.setiputsizes(). The event
      passes a dictionary of BindParameter objects to DBAPI-specific
      type objects that will be passed, after conversion to parameter
      names, to the cx_Oracle cursor.setinputsizes() method. This
      allows both visibility into the setinputsizes process as well as
      the ability to alter the behavior of what datatypes are passed
      to this method.
      See als Fine grained control over cx_Oracle data binding and performance with setinputsizes
      References: #4290
      + [oracle] [bug] [mysql] Fixed INSERT FROM SELECT with CTEs for
      the Oracle and MySQL dialects, where the CTE was being placed
      above the entire statement as is typical with other databases,
      however Oracle and MariaDB 10.2 wants the CTE underneath the
      “INSERT” segment. Note that the Oracle and MySQL dialects don’t
      yet work when a CTE is applied to a subquery inside of an UPDATE
      or DELETE statement, as the CTE is still applied to the top
      rather than inside the subquery.
      References: #4275
    * misc
      + [feature] [ext] Added new attribute Query.lazy_loaded_from which
      is populated with an InstanceState that is using this Query in
      order to lazy load a relationship. The rationale for this is
      that it serves as a hint for the horizontal sharding feature to
      use, such that the identity token of the state can be used as
      the default identity token to use for the query within
      id_chooser().
      References: #4243
      + [bug] [py3k] Replaced the usage of inspect.formatargspec() with
      a vendored version copied from the Python standard library, as
      inspect.formatargspec() is deprecated and as of Python 3.7.0 is
      emitting a warning.
      References: #4291
* Tue Jun 26 2018 mimi.vx@gmail.com
  - add upstream fix_test_reflection.patch to fix tests with new sqlite
* Thu Jun 21 2018 hpj@urpla.net
  - update to version 1.2.8:
    * orm
      + [orm] [bug] Fixed regression in 1.2.7 caused by #4228, which
      itself was fixing a 1.2-level regression, where the query_cls
      callable passed to a Session was assumed to be a subclass of
      Query with class method availability, as opposed to an
      arbitrary callable. In particular, the dogpile caching example
      illustrates query_cls as a function and not a Query subclass.
      References: #4256
      + [orm] [bug] Fixed a long-standing regression that occurred in
      version 1.0, which prevented the use of a custom MapperOption
      that alters the _params of a Query object for a lazy load,
      since the lazy loader itself would overwrite those parameters.
      This applies to the “temporal range” example on the wiki. Note
      however that the Query.populate_existing() method is now
      required in order to rewrite the mapper options associated with
      an object already loaded in the identity map.
      As part of this change, a custom defined MapperOption will now
      cause lazy loaders related to the target object to use a non-
      baked query by default unless the
      MapperOption._generate_cache_key() method is implemented. In
      particular, this repairs one regression which occured when
      using the dogpile.cache “advanced” example, which was not
      returning cached results and instead emitting SQL due to an
      incompatibility with the baked query loader; with the change,
      the RelationshipCache option included for many releases in the
      dogpile example will disable the “baked” query altogether. Note
      that the dogpile example is also modernized to avoid both of
      these issues as part of issue #4258.  References: #4128
      + [orm] [bug] Fixed bug where the new
      baked.Result.with_post_criteria() method would not interact
      with a subquery-eager loader correctly, in that the “post
      criteria” would not be applied to embedded subquery
      eager loaders. This is related to #4128 in that the post
      criteria feature is now used by the lazy loader.
      + [orm] [bug] Updated the dogpile.caching example to include new
      structures that accommodate for the “baked” query system, which
      is used by default within lazy loaders and some eager
      relationship loaders. The dogpile.caching “relationship_caching”
      and “advanced” examples were also broken due to #4256. The
      issue here is also worked-around by the fix in #4128.
      References: #4258
    * engine
      + [engine] [bug] Fixed connection pool issue whereby if a
      disconnection error were raised during the connection pool’s
      “reset on return” sequence in conjunction with an explicit
      transaction opened against the enclosing Connection object
      (such as from calling Session.close() without a rollback or
      commit, or calling Connection.close() without first closing a
      transaction declared with Connection.begin()), a double-checkin
      would result, which could then lead towards concurrent
      checkouts of the same connection. The double-checkin condition
      is now prevented overall by an assertion, as well as the
      specific double-checkin scenario has been fixed.
      References: #4252
      + [engine] [bug] Fixed a reference leak issue where the values of
      the parameter dictionary used in a statement execution would
      remain referenced by the “compiled cache”, as a result of
      storing the key view used by Python 3 dictionary keys(). Pull
      request courtesy Olivier Grisel.
    * sql
      + [sql] [bug] Fixed issue where the “ambiguous literal” error
      message used when interpreting literal values as SQL expression
      values would encounter a tuple value, and fail to format the
      message properly. Pull request courtesy Miguel Ventura.
    * mssql
      + [mssql] [bug] Fixed a 1.2 regression caused by #4061 where the
      SQL Server “BIT” type would be considered to be “native
      boolean”. The goal here was to avoid creating a CHECK
      constraint on the column, however the bigger issue is that the
      BIT value does not behave like a true/false constant and cannot
      be interpreted as a standalone expression, e.g.  “WHERE
      <column>”. The SQL Server dialect now goes back to being non-
      native boolean, but with an extra flag that still avoids
      creating the CHECK constraint.  References: #4250
    * oracle
      + [oracle] [bug] The Oracle BINARY_FLOAT and BINARY_DOUBLE
      datatypes now participate within cx_Oracle.setinputsizes(),
      passing along NATIVE_FLOAT, so as to support the NaN value.
      Additionally, oracle.BINARY_FLOAT, oracle.BINARY_DOUBLE and
      oracle.DOUBLE_PRECISION now subclass Float, since these are
      floating point datatypes, not decimal. These datatypes were
      already defaulting the Float.asdecimal flag to False in line
      with what Float already does.  References: #4264
      + [oracle] [bug] Added reflection capabilities for the
      oracle.BINARY_FLOAT, oracle.BINARY_DOUBLE datatypes.
      + [oracle] [bug] Altered the Oracle dialect such that when an
      Integer type is in use, the cx_Oracle.NUMERIC type is set up
      for setinputsizes(). In SQLAlchemy 1.1 and earlier,
      cx_Oracle.NUMERIC was passed for all numeric types
      unconditionally, and in 1.2 this was removed to allow for
      better numeric precision. However, for integers, some
      database/client setups will fail to coerce boolean values
      True/False into integers which introduces regressive behavior
      when using SQLAlchemy 1.2. Overall, the setinputsizes logic
      seems like it will need a lot more flexibility going forward so
      this is a start for that.  References: #4259
    * misc
      + [bug] [ext] The horizontal sharding extension now makes use of
      the identity token added to ORM identity keys as part of #4137,
      when an object refresh or column-based deferred load or
      unexpiration operation occurs.  Since we know the “shard” that
      the object originated from, we make use of this value when
      refreshing, thereby avoiding queries against other shards that
      don’t match this object’s identity in any case.
      References: #4247
      + [bug] [ext] Fixed a race condition which could occur if automap
      AutomapBase.prepare() were used within a multi-threaded context
      against other threads which may call configure_mappers() as a
      result of use of other mappers. The unfinished mapping work of
      automap is particularly sensitive to being pulled in by a
      configure_mappers() step leading to errors.  References: #4266
      + [bug] [tests] Fixed a bug in the test suite where if an
      external dialect returned None for server_version_info, the
      exclusion logic would raise an AttributeError.
      References: #4249
* Sat Apr 21 2018 arun@gmx.de
  - update to version 1.2.7:
    * orm
      + [orm] [bug] Fixed regression in 1.2 within sharded query feature
      where the new “identity_token” element was not being correctly
      considered within the scope of a lazy load operation, when
      searching the identity map for a related many-to-one
      element. The new behavior will allow for making use of the
      “id_chooser” in order to determine the best identity key to
      retrieve from the identity map. In order to achieve this, some
      refactoring of 1.2’s “identity_token” approach has made some
      slight changes to the implementation of ShardedQuery which
      should be noted for other derivations of this class.
      References: #4228
      + [orm] [bug] Fixed issue in single-inheritance loading where the
      use of an aliased entity against a single-inheritance subclass
      in conjunction with the Query.select_from() method would cause
      the SQL to be rendered with the unaliased table mixed in to the
      query, causing a cartesian product. In particular this was
      affecting the new “selectin” loader when used against a
      single-inheritance subclass.  References: #4241
    * sql
      + [sql] [bug] Fixed issue where the compilation of an INSERT
      statement with the “literal_binds” option that also uses an
      explicit sequence and “inline” generation, as on Postgresql and
      Oracle, would fail to accommodate the extra keyword argument
      within the sequence processing routine.  References: #4231
    * postgresql
      + [postgresql] [feature] Added new PG type postgresql.REGCLASS
      which assists in casting table names to OID values. Pull request
      courtesy Sebastian Bank.  References: #4160
      + [postgresql] [bug] Fixed bug where the special “not equals”
      operator for the Postgresql “range” datatypes such as DATERANGE
      would fail to render “IS NOT NULL” when compared to the Python
      None value.  References: #4229
    * mssql
      + [mssql] [bug] Fixed 1.2 regression caused by #4060 where the
      query used to reflect SQL Server cross-schema foreign keys was
      limiting the criteria incorrectly.  References: #4234
    * oracle
      + [oracle] [bug] The Oracle NUMBER datatype is reflected as
      INTEGER if the precision is NULL and the scale is zero, as this
      is how INTEGER values come back when reflected from Oracle’s
      tables. Pull request courtesy Kent Bower.
* Sun Apr 01 2018 arun@gmx.de
  - specfile:
    * run spec-cleaner
  - update to version 1.2.6:
    * orm
      + [orm] [bug] Fixed bug where using Mutable.associate_with() or
      Mutable.as_mutable() in conjunction with a class that has non-
      primary mappers set up with alternatively-named attributes would
      produce an attribute error. Since non-primary mappers are not
      used for persistence, the mutable extension now excludes
      non-primary mappers from its instrumentation steps.  References:
      [#4215]
    * engine
      + [engine] [bug] Fixed bug in connection pool where a connection
      could be present in the pool without all of its “connect” event
      handlers called, if a previous “connect” handler threw an
      exception; note that the dialects themselves have connect
      handlers that emit SQL, such as those which set transaction
      isolation, which can fail if the database is in a non-available
      state, but still allows a connection. The connection is now
      invalidated first if any of the connect handlers fail.
      References: #4225
    * sql
      + [sql] [bug] Fixed a regression that occurred from the previous
      fix to #4204 in version 1.2.5, where a CTE that refers to itself
      after the CTE.alias() method has been called would not refer to
      iself correctly.  References: #4204
    * postgresql
      + [postgresql] [feature] Added support for “PARTITION BY” in
      Postgresql table definitions, using
      “postgresql_partition_by”. Pull request courtesy Vsevolod
      Solovyov.
    * mssql
      + [mssql] [bug] Adjusted the SQL Server version detection for
      pyodbc to only allow for numeric tokens, filtering out
      non-integers, since the dialect does tuple- numeric comparisons
      with this value. This is normally true for all known SQL Server
      / pyodbc drivers in any case.  References: #4227
    * oracle
      + [oracle] [bug] The minimum cx_Oracle version supported is 5.2
      (June 2015). Previously, the dialect asserted against version
      5.0 but as of 1.2.2 we are using some symbols that did not
      appear until 5.2.  References: #4211
    * misc
      + [bug] [declarative] Removed a warning that would be emitted when
      calling upon __table_args__, __mapper_args__ as named with a
      @declared_attr method, when called from a non-mapped declarative
      mixin. Calling these directly is documented as the approach to
      use when one is overidding one of these methods on a mapped
      class. The warning still emits for regular attribute names.
      References: #4221
* Thu Mar 08 2018 arun@gmx.de
  - update to version 1.2.5:
    * orm
      + [orm] [feature] Added new feature
      Query.only_return_tuples(). Causes the Query object to return
      keyed tuple objects unconditionally even if the query is against
      a single entity. Pull request courtesy Eric Atkin.
      + [orm] [bug] Fixed bug in new “polymorphic selectin” loading when
      a selection of polymorphic objects were to be partially loaded
      from a relationship lazy loader, leading to an “empty IN”
      condition within the load that raises an error for the “inline”
      form of “IN”. References: #4199
      + [orm] [bug] Fixed 1.2 regression where a mapper option that
      contains an AliasedClass object, as is typical when using the
      QueryableAttribute.of_type() method, could not be pickled. 1.1’s
      behavior was to omit the aliased class objects from the path, so
      this behavior is restored.  References: #4209
    * sql
      + [sql] [bug] Fixed bug in :class:.`CTE` construct along the same
      lines as that of #4204 where a CTE that was aliased would not
      copy itself correctly during a “clone” operation as is frequent
      within the ORM as well as when using the ClauseElement.params()
      method.  References: #4210
      + [sql] [bug] Fixed bug in CTE rendering where a CTE that was also
      turned into an Alias would not render its “ctename AS aliasname”
      clause appropriately if there were more than one reference to
      the CTE in a FROM clause.  References: #4204
      + [sql] [bug] Fixed bug in new “expanding IN parameter” feature
      where the bind parameter processors for values wasn’t working at
      all, tests failed to cover this pretty basic case which includes
      that ENUM values weren’t working.  References: #4198
    * postgresql
      + [postgresql] [bug] [py3k] Fixed bug in Postgresql COLLATE /
      ARRAY adjustment first introduced in #4006 where new behaviors
      in Python 3.7 regular expressions caused the fix to fail.  This
      change is also backported to: 1.1.18 References: #4208
    * mysql
      + [mysql] [bug] MySQL dialects now query the server version using
      SELECT @@version explicitly to the server to ensure we are
      getting the correct version information back. Proxy servers like
      MaxScale interfere with the value that is passed to the DBAPI’s
      connection.server_version value so this is no longer reliable.
      This change is also backported to: 1.1.18 References: #4205
* Fri Feb 23 2018 arun@gmx.de
  - update to version 1.2.4:
    * orm
      + [orm] [bug] Fixed 1.2 regression in ORM versioning feature where
      a mapping against a select() or alias() that also used a
      versioning column against the underlying table would fail due to
      the check added as part of #3673.  References: #4193
    * engine
      + [engine] [bug] Fixed regression caused in 1.2.3 due to fix from
      [#4181] where the changes to the event system involving Engine and
      OptionEngine did not accommodate for event removals, which would
      raise an AttributeError when invoked at the class level.
      References: #4190
    * sql
      + [sql] [bug] Fixed bug where CTE expressions would not have their
      name or alias name quoted when the given name is case sensitive
      or otherwise requires quoting. Pull request courtesy Eric Atkin.
      References: #4197
* Sun Feb 18 2018 arun@gmx.de
  - update to version 1.2.3:
    * orm
      + [orm] [feature] Added new argument
      attributes.set_attribute.inititator to the
      attributes.set_attribute() function, allowing an event token
      received from a listener function to be propagated to subsequent
      set events.
      + [orm] [bug] Fixed issue in post_update feature where an UPDATE
      is emitted when the parent object has been deleted but the
      dependent object is not. This issue has existed for a long time
      however since 1.2 now asserts rows matched for post_update, this
      was raising an error.  This change is also backported to: 1.1.16
      References: #4187
      + [orm] [bug] Fixed regression caused by fix for issue #4116
      affecting versions 1.2.2 as well as 1.1.15, which had the effect
      of mis-calculation of the “owning class” of an AssociationProxy
      as the NoneType class in some declarative mixin/inheritance
      situations as well as if the association proxy were accessed off
      of an un-mapped class. The “figure out the owner” logic has been
      replaced by an in-depth routine that searches through the
      complete mapper hierarchy assigned to the class or subclass to
      determine the correct (we hope) match; will not assign the owner
      if no match is found. An exception is now raised if the proxy is
      used against an un-mapped instance.  This change is also
      backported to: 1.1.16 References: #4185
      + [orm] [bug] Fixed bug where the Bundle object did not correctly
      report upon the primary Mapper object represened by the bundle,
      if any. An immediate side effect of this issue was that the new
      selectinload loader strategy wouldn’t work with the horizontal
      sharding extension.  References: #4175
      + [orm] [bug] Fixed bug in concrete inheritance mapping where
      user-defined attributes such as hybrid properties that mirror
      the names of mapped attributes from sibling classes would be
      overwritten by the mapper as non-accessible at the instance
      level. Additionally ensured that user-bound descriptors are not
      implicitly invoked at the class level during the mapper
      configuration stage.  References: #4188
      + [orm] [bug] Fixed bug where the orm.reconstructor() event helper
      would not be recognized if it were applied to the __init__()
      method of the mapped class.  References: #4178
    * engine
      + [engine] [bug] Fixed bug where events associated with an Engine
      at the class level would be doubled when the
      Engine.execution_options() method were used. To achieve this,
      the semi-private class OptionEngine no longer accepts events
      directly at the class level and will raise an error; the class
      only propagates class-level events from its parent
      Engine. Instance-level events continue to work as before.
      References: #4181
      + [engine] [bug] The URL object now allows query keys to be
      specified multiple times where their values will be joined into
      a list. This is to support the plugins feature documented at
      CreateEnginePlugin which documents that “plugin” can be passed
      multiple times. Additionally, the plugin names can be passed to
      create_engine() outside of the URL using the new
      create_engine.plugins parameter.  References: #4170
    * sql
      + [sql] [feature] Added support for Enum to persist the values of
      the enumeration, rather than the keys, when using a Python
      pep-435 style enumerated object. The user supplies a callable
      function that will return the string values to be
      persisted. This allows enumerations against non-string values to
      be value-persistable as well. Pull request courtesy Jon Snyder.
      References: #3906
      + [sql] [bug] Fixed bug where the Enum type wouldn’t handle enum
      “aliases” correctly, when more than one key refers to the same
      value. Pull request courtesy Daniel Knell.  References: #4180
    * postgresql
      + [postgresql] [bug] Added “SSL SYSCALL error: Operation timed
      out” to the list of messages that trigger a “disconnect”
      scenario for the psycopg2 driver. Pull request courtesy André
      Cruz.  This change is also backported to: 1.1.16
      + [postgresql] [bug] Added “TRUNCATE” to the list of keywords
      accepted by the Postgresql dialect as an “autocommit”-triggering
      keyword. Pull request courtesy Jacob Hayes.  This change is also
      backported to: 1.1.16
    * sqlite
      + [sqlite] [bug] Fixed the import error raised when a platform has
      neither pysqlite2 nor sqlite3 installed, such that the
      sqlite3-related import error is raised, not the pysqlite2 one
      which is not the actual failure mode. Pull request courtesy
      Robin.
    * oracle
      + [oracle] [feature] The ON DELETE options for foreign keys are
      now part of Oracle reflection. Oracle does not support ON UPDATE
      cascades. Pull request courtesy Miroslav Shubernetskiy.
      + [oracle] [bug] Fixed bug in cx_Oracle disconnect detection, used
      by pre_ping and other features, where an error could be raised
      as DatabaseError which includes a numeric error code; previously
      we weren’t checking in this case for a disconnect code.
      References: #4182
    * misc
      + [bug] [pool] Fixed a fairly serious connection pool bug where a
      connection that is acquired after being refreshed as a result of
      a user-defined DisconnectionError or due to the 1.2-released
      “pre_ping” feature would not be correctly reset if the
      connection were returned to the pool by weakref cleanup
      (e.g. the front-facing object is garbage collected); the weakref
      would still refer to the previously invalidated DBAPI connection
      which would have the reset operation erroneously called upon it
      instead. This would lead to stack traces in the logs and a
      connection being checked into the pool without being reset,
      which can cause locking issues.  This change is also backported
      to: 1.1.16 References: #4184
      + [bug] [tests] A test added in 1.2 thought to confirm a Python
      2.7 behavior turns out to be confirming the behavior only as of
      Python 2.7.8. Python bug #8743 still impacts set comparison in
      Python 2.7.7 and earlier, so the test in question involving
      AssociationSet no longer runs for these older Python 2.7
      versions.  References: #3265
* Sun Jan 28 2018 arun@gmx.de
  - update to version 1.2.2:
    * orm
      + [orm] [bug] Fixed 1.2 regression regarding new bulk_replace
      event where a backref would fail to remove an object from the
      previous owner when a bulk-assignment assigned the object to a
      new owner.  References: #4171
    * mysql
      + [mysql] [bug] Added more MySQL 8.0 reserved words to the MySQL
      dialect for quoting purposes. Pull request courtesy Riccardo
      Magliocchetti.
    * mssql
      + [mssql] [bug] Added ODBC error code 10054 to the list of error
      codes that count as a disconnect for ODBC / MSSQL server.
      References: #4164
    * oracle
      + [oracle] [bug] The cx_Oracle dialect now calls setinputsizes()
      with cx_Oracle.NCHAR unconditionally when the NVARCHAR2
      datatype, in SQLAlchemy corresponding to sqltypes.Unicode(), is
      in use. Per cx_Oracle’s author this allows the correct
      conversions to occur within the Oracle client regardless of the
      setting for NLS_NCHAR_CHARACTERSET.  References: #4163
* Wed Jan 17 2018 arun@gmx.de
  - update to version 1.2.1:
    * orm
      + [orm] [bug] Fixed bug where an object that is expunged during a
      rollback of a nested or subtransaction which also had its
      primary key mutated would not be correctly removed from the
      session, causing subsequent issues in using the session.
      + [orm] [bug] Fixed regression where pickle format of a Load /
      _UnboundLoad object (e.g. loader options) changed and
      __setstate__() was raising an UnboundLocalError for an object
      received from the legacy format, even though an attempt was made
      to do so. tests are now added to ensure this works.
      + [orm] [bug] Fixed regression caused by new lazyload caching
      scheme in #3954 where a query that makes use of loader options
      with of_type would cause lazy loads of unrelated paths to fail
      with a TypeError.
      + [orm] [bug] Fixed bug in new “selectin” relationship loader
      where the loader could try to load a non-existent relationship
      when loading a collection of polymorphic objects, where only
      some of the mappers include that relationship, typically when
      PropComparator.of_type() is being used.
    * sql
      + [sql] [bug] Fixed bug in Insert.values() where using the
      “multi-values” format in combination with Column objects as keys
      rather than strings would fail. Pull request courtesy Aubrey
      Stark-Toller.
    * mssql
      + [mssql] [bug] Fixed regression in 1.2 where newly repaired
      quoting of collation names in #3785 breaks SQL Server, which
      explicitly does not understand a quoted collation name. Whether
      or not mixed-case collation names are quoted or not is now
      deferred down to a dialect-level decision so that each dialect
      can prepare these identifiers directly.
    * oracle
      + [oracle] [bug] Fixed regression where the removal of most
      setinputsizes rules from cx_Oracle dialect impacted the
      TIMESTAMP datatype’s ability to retrieve fractional seconds.
      + [oracle] [bug] Fixed regression in Oracle imports where a
      missing comma caused an undefined symbol to be present. Pull
      request courtesy Miroslav Shubernetskiy.
    * misc
      + [bug] [ext] Fixed regression in association proxy due to #3769
      (allow for chained any() / has()) where contains() against an
      association proxy chained in the form (o2m relationship,
      associationproxy(m2o relationship, m2o relationship)) would
      raise an error regarding the re-application of contains() on the
      final link of the chain.
      + [bug] [tests] Removed an oracle-specific requirements rule from
      the public test suite that was interfering with third party
      dialect suites.
      + [bug] [tests] Added a new exclusion rule
      group_by_complex_expression which disables tests that use “GROUP
      BY <expr>”, which seems to be not viable for at least two third
      party dialects.
* Wed Jan 03 2018 arun@gmx.de
  - specfile:
    * updated test requirements
* Sun Dec 31 2017 arun@gmx.de
  - update to version 1.2.0:
    * See https://docs.sqlalchemy.org/en/latest/changelog/changelog_12.html
* Mon Sep 25 2017 arun@gmx.de
  - update to version 1.1.14:
    * orm
      + [orm] [bug] Fixed bug in Session.merge() following along similar
      lines as that of #4030, where an internal check for a target
      object in the identity map could lead to an error if it were to
      be garbage collected immediately before the merge routine
      actually retrieves the object. References: #4069
      + [orm] [bug] Fixed bug where an undefer_group() option would not
      be recognized if it extended from a relationship that was
      loading using joined eager loading. Additionally, as the bug led
      to excess work being performed, Python function call counts are
      also improved by 20% within the initial calculation of result
      set columns, complementing the joined eager load improvements of
      [#3915].    References: #4048
      + [orm] [bug] Fixed race condition in ORM identity map which would
      cause objects to be inappropriately removed during a load
      operation, causing duplicate object identities to occur,
      particularly under joined eager loading which involves
      deduplication of objects. The issue is specific to garbage
      collection of weak references and is observed only under the
      Pypy interpreter.    References: #4068
      + [orm] [bug] Fixed bug in Session.merge() where objects in a
      collection that had the primary key attribute set to None for a
      key that is typically autoincrementing would be considered to be
      a database-persisted key for part of the internal deduplication
      process, causing only one object to actually be inserted in the
      database.    References: #4056
      + [orm] [bug] An InvalidRequestError is raised when a synonym() is
      used against an attribute that is not against a MapperProperty,
      such as an association proxy. Previously, a recursion overflow
      would occur trying to locate non-existent attributes.  References: #4067
    * sql
      + [sql] [bug] Altered the range specification for window functions
      to allow for two of the same PRECEDING or FOLLOWING keywords in
      a range by allowing for the left side of the range to be
      positive and for the right to be negative, e.g. (1, 3) is “1
      FOLLOWING AND 3 FOLLOWING”.    References: #4053
  - changes from version 1.1.13:
    * oracle
      + [oracle] [bug] [py2k] [performance] Fixed performance regression
      caused by the fix for #3937 where cx_Oracle as of version 5.3
      dropped the .UNICODE symbol from its namespace, which was
      interpreted as cx_Oracle’s “WITH_UNICODE” mode being turned on
      unconditionally, which invokes functions on the SQLAlchemy side
      which convert all strings to unicode unconditionally and causing
      a performance impact. In fact, per cx_Oracle’s author the
      “WITH_UNICODE” mode has been removed entirely as of 5.1, so the
      expensive unicode conversion functions are no longer necessary
      and are disabled if cx_Oracle 5.1 or greater is detected under
      Python 2. The warning against “WITH_UNICODE” mode that was
      removed under #3937 is also restored.
      This change is also backported to: 1.0.19
      References: #4035
* Tue Aug 08 2017 tbechtold@suse.com
  - update to 1.1.12:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.12
* Fri Jul 07 2017 tbechtold@suse.com
  - Update to 1.1.11:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.11
  - Update to 1.1.10:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.10
* Sat May 06 2017 toddrme2178@gmail.com
  - Don't provide python2-sqlalchemy, singlespec packages should use
    correct name.
* Mon May 01 2017 toddrme2178@gmail.com
  - Add literal python-sqlalchemy provides.
* Tue Apr 18 2017 toddrme2178@gmail.com
  - Update to 1.1.9:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.9
  - Update to 1.1.8:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.8
  - Update to 1.1.7:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.7
  - Update to 1.1.6:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.6
  - Update to 1.1.5:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.5
  - Update to 1.1.4:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.4
  - Update to 1.1.3:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.3
  - Update to 1.1.2:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.2
  - Update to 1.1.1:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.1
  - Update to 1.1.0:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_11.html#change-1.1.0
  - Update to 1.0.18:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.18
  - Update to 1.0.17:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.17
  - Update to 1.0.16:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.16
  - Implement single-spec version.
* Thu Sep 15 2016 toddrme2178@gmail.com
  - Update to 1.0.15:
    * See http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.15
    http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.14
* Mon Jun 06 2016 dmueller@suse.com
  - fix source url
* Fri Jun 03 2016 tbechtold@suse.com
  - update to 1.0.13:
    * see http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.12
      and http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.13
    Remove 0001-fix-sqlite3.10.0-test.patch. Applied upstream.
* Thu Feb 11 2016 aplanas@suse.com
  - Add 0001-fix-sqlite3.10.0-test.patch
    Backport fix after SQLite3.10 upgrade
* Mon Jan 11 2016 bwiedemann@suse.com
  - update to 1.0.11:
    * see http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.11
* Sun Oct 04 2015 tbechtold@suse.com
  - update to 1.0.8:
    * see http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.8
* Mon Jun 15 2015 bruno@ioda-net.ch
  - update to version 1.0.5:
    * see http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.5
* Sun May 24 2015 bruno@ioda-net.ch
  - update to 1.0.4:
    + see http://docs.sqlalchemy.org/en/latest/changelog/changelog_10.html#change-1.0.4
    + see http://docs.sqlalchemy.org/en/latest/changelog/migration_10.html
* Wed Apr 22 2015 tbechtold@suse.com
  - update to 0.9.9:
    + See http://docs.sqlalchemy.org/en/latest/changelog/changelog_09.html#change-0.9.9
* Thu Jan 08 2015 tbechtold@suse.com
  - Update to version 0.9.8:
    + See http://docs.sqlalchemy.org/en/latest/changelog/changelog_09.html#change-0.9.8

Files

/usr/lib64/python2.7/site-packages/SQLAlchemy-1.2.14-py2.7.egg-info
/usr/lib64/python2.7/site-packages/SQLAlchemy-1.2.14-py2.7.egg-info/PKG-INFO
/usr/lib64/python2.7/site-packages/SQLAlchemy-1.2.14-py2.7.egg-info/SOURCES.txt
/usr/lib64/python2.7/site-packages/SQLAlchemy-1.2.14-py2.7.egg-info/dependency_links.txt
/usr/lib64/python2.7/site-packages/SQLAlchemy-1.2.14-py2.7.egg-info/requires.txt
/usr/lib64/python2.7/site-packages/SQLAlchemy-1.2.14-py2.7.egg-info/top_level.txt
/usr/lib64/python2.7/site-packages/sqlalchemy
/usr/lib64/python2.7/site-packages/sqlalchemy/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/mxodbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/mxodbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/mxodbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/pyodbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/pyodbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/pyodbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/zxJDBC.py
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/zxJDBC.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/connectors/zxJDBC.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/cprocessors.so
/usr/lib64/python2.7/site-packages/sqlalchemy/cresultproxy.so
/usr/lib64/python2.7/site-packages/sqlalchemy/cutils.so
/usr/lib64/python2.7/site-packages/sqlalchemy/databases
/usr/lib64/python2.7/site-packages/sqlalchemy/databases/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/databases/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/databases/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/fdb.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/fdb.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/fdb.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/kinterbasdb.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/kinterbasdb.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/firebird/kinterbasdb.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/adodbapi.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/adodbapi.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/adodbapi.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/information_schema.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/information_schema.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/information_schema.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/mxodbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/mxodbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/mxodbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/pymssql.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/pymssql.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/pymssql.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/pyodbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/pyodbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/pyodbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/zxjdbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/zxjdbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mssql/zxjdbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/cymysql.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/cymysql.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/cymysql.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/dml.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/dml.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/dml.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/enumerated.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/enumerated.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/enumerated.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/gaerdbms.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/gaerdbms.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/gaerdbms.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/json.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/json.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/json.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/mysqlconnector.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/mysqlconnector.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/mysqlconnector.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/mysqldb.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/mysqldb.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/mysqldb.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/oursql.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/oursql.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/oursql.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/pymysql.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/pymysql.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/pymysql.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/pyodbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/pyodbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/pyodbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/reflection.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/reflection.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/reflection.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/types.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/types.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/types.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/zxjdbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/zxjdbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/mysql/zxjdbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/cx_oracle.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/cx_oracle.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/cx_oracle.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/zxjdbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/zxjdbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/oracle/zxjdbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/array.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/array.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/array.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/dml.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/dml.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/dml.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/ext.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/ext.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/ext.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/hstore.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/hstore.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/hstore.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/json.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pg8000.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pg8000.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pg8000.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/psycopg2.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/psycopg2.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/psycopg2.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/psycopg2cffi.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/psycopg2cffi.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/psycopg2cffi.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pygresql.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pygresql.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pygresql.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pypostgresql.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pypostgresql.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/pypostgresql.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/ranges.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/ranges.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/ranges.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/zxjdbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/zxjdbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/zxjdbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/pysqlcipher.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/pysqlcipher.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/pysqlcipher.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/pysqlite.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/pysqlite.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sqlite/pysqlite.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/mxodbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/mxodbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/mxodbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/pyodbc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/pyodbc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/pyodbc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/pysybase.py
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/pysybase.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/dialects/sybase/pysybase.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/default.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/default.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/default.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/interfaces.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/interfaces.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/interfaces.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/result.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/strategies.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/strategies.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/strategies.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/threadlocal.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/threadlocal.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/threadlocal.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/url.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/url.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/url.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/util.py
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/util.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/engine/util.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/event
/usr/lib64/python2.7/site-packages/sqlalchemy/event/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/event/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/event/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/event/api.py
/usr/lib64/python2.7/site-packages/sqlalchemy/event/api.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/event/api.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/event/attr.py
/usr/lib64/python2.7/site-packages/sqlalchemy/event/attr.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/event/attr.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/event/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/event/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/event/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/event/legacy.py
/usr/lib64/python2.7/site-packages/sqlalchemy/event/legacy.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/event/legacy.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/event/registry.py
/usr/lib64/python2.7/site-packages/sqlalchemy/event/registry.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/event/registry.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/events.py
/usr/lib64/python2.7/site-packages/sqlalchemy/events.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/events.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/exc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/exc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/exc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/associationproxy.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/associationproxy.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/associationproxy.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/automap.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/automap.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/automap.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/baked.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/baked.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/compiler.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/compiler.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/compiler.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/api.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/api.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/api.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/clsregistry.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/clsregistry.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/declarative/clsregistry.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/horizontal_shard.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/horizontal_shard.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/horizontal_shard.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/hybrid.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/hybrid.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/hybrid.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/indexable.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/indexable.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/indexable.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/instrumentation.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/instrumentation.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/instrumentation.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/mutable.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/mutable.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/mutable.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/serializer.py
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/serializer.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/ext/serializer.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/inspection.py
/usr/lib64/python2.7/site-packages/sqlalchemy/inspection.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/inspection.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/interfaces.py
/usr/lib64/python2.7/site-packages/sqlalchemy/interfaces.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/interfaces.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/log.py
/usr/lib64/python2.7/site-packages/sqlalchemy/log.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/log.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/attributes.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/attributes.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/attributes.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/collections.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/collections.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/collections.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/dependency.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/dependency.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/dependency.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/deprecated_interfaces.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/deprecated_interfaces.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/deprecated_interfaces.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/descriptor_props.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/descriptor_props.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/descriptor_props.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/dynamic.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/dynamic.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/dynamic.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/evaluator.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/evaluator.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/evaluator.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/events.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/events.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/events.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/exc.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/exc.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/exc.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/identity.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/identity.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/identity.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/instrumentation.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/instrumentation.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/instrumentation.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/interfaces.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/interfaces.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/interfaces.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/loading.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/loading.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/loading.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/mapper.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/mapper.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/mapper.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/path_registry.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/path_registry.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/path_registry.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/persistence.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/persistence.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/persistence.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/properties.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/properties.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/properties.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/query.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/query.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/query.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/relationships.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/relationships.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/relationships.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/scoping.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/scoping.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/scoping.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/session.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/session.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/session.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/state.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/state.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/state.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/strategies.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/strategies.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/strategies.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/strategy_options.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/sync.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/sync.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/sync.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/unitofwork.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/unitofwork.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/unitofwork.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/util.py
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/util.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/orm/util.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/pool.py
/usr/lib64/python2.7/site-packages/sqlalchemy/pool.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/pool.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/processors.py
/usr/lib64/python2.7/site-packages/sqlalchemy/processors.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/processors.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/schema.py
/usr/lib64/python2.7/site-packages/sqlalchemy/schema.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/schema.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/annotation.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/annotation.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/annotation.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/compiler.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/compiler.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/compiler.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/crud.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/crud.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/crud.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/ddl.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/ddl.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/ddl.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/default_comparator.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/default_comparator.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/default_comparator.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/dml.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/dml.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/dml.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/elements.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/elements.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/expression.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/expression.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/expression.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/functions.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/functions.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/functions.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/naming.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/naming.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/naming.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/operators.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/operators.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/schema.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/schema.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/schema.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/selectable.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/selectable.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/selectable.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/sqltypes.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/sqltypes.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/sqltypes.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/type_api.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/type_api.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/type_api.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/util.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/util.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/util.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/visitors.py
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/visitors.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/sql/visitors.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/assertions.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/assertions.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/assertions.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/assertsql.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/assertsql.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/assertsql.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/config.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/config.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/config.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/engines.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/engines.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/engines.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/entities.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/entities.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/entities.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/exclusions.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/exclusions.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/exclusions.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/fixtures.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/fixtures.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/fixtures.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/mock.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/mock.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/mock.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/pickleable.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/pickleable.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/pickleable.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/bootstrap.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/bootstrap.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/bootstrap.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/noseplugin.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/noseplugin.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/noseplugin.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/plugin_base.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/plugin_base.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/plugin_base.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/pytestplugin.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/pytestplugin.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/plugin/pytestplugin.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/profiling.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/profiling.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/profiling.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/provision.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/provision.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/provision.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/replay_fixture.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/replay_fixture.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/replay_fixture.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/requirements.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/requirements.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/requirements.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/runner.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/runner.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/runner.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/schema.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/schema.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/schema.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_cte.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_cte.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_cte.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_ddl.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_ddl.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_ddl.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_dialect.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_dialect.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_dialect.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_insert.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_insert.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_insert.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_reflection.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_reflection.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_reflection.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_results.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_results.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_results.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_select.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_select.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_select.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_sequence.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_sequence.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_sequence.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_types.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_types.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_types.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_update_delete.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_update_delete.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/suite/test_update_delete.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/util.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/util.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/util.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/warnings.py
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/warnings.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/testing/warnings.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/types.py
/usr/lib64/python2.7/site-packages/sqlalchemy/types.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/types.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/util
/usr/lib64/python2.7/site-packages/sqlalchemy/util/__init__.py
/usr/lib64/python2.7/site-packages/sqlalchemy/util/__init__.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/util/__init__.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/util/_collections.py
/usr/lib64/python2.7/site-packages/sqlalchemy/util/_collections.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/util/_collections.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/util/compat.py
/usr/lib64/python2.7/site-packages/sqlalchemy/util/compat.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/util/compat.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/util/deprecations.py
/usr/lib64/python2.7/site-packages/sqlalchemy/util/deprecations.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/util/deprecations.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/util/langhelpers.py
/usr/lib64/python2.7/site-packages/sqlalchemy/util/langhelpers.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/util/langhelpers.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/util/queue.py
/usr/lib64/python2.7/site-packages/sqlalchemy/util/queue.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/util/queue.pyo
/usr/lib64/python2.7/site-packages/sqlalchemy/util/topological.py
/usr/lib64/python2.7/site-packages/sqlalchemy/util/topological.pyc
/usr/lib64/python2.7/site-packages/sqlalchemy/util/topological.pyo
/usr/share/doc/packages/python2-SQLAlchemy
/usr/share/doc/packages/python2-SQLAlchemy/CHANGES
/usr/share/doc/packages/python2-SQLAlchemy/README.dialects.rst
/usr/share/doc/packages/python2-SQLAlchemy/README.rst
/usr/share/doc/packages/python2-SQLAlchemy/README.unittests.rst
/usr/share/licenses/python2-SQLAlchemy
/usr/share/licenses/python2-SQLAlchemy/LICENSE

Generated by rpm2html 1.8.1

Fabrice Bellet, Tue Jul 9 12:46:04 2024