- Moved to 2.4+ import syntax (w/ some experimental merge-friendly formatting)

lib/sqlalchemy/__init__.py

@@ -10,32 +10,102 @@ import sys
 import sqlalchemy.exc as exceptions
 sys.modules['sqlalchemy.exceptions'] = exceptions
 
-from sqlalchemy.types import \
-    BLOB, BOOLEAN, CHAR, CLOB, DATE, DATETIME, DECIMAL, FLOAT, INT, \
-    NCHAR, NUMERIC, SMALLINT, TEXT, TIME, TIMESTAMP, VARCHAR, \
-    Binary, Boolean, Date, DateTime, Float, Integer, Interval, Numeric, \
-    PickleType, SmallInteger, String, Text, Time, Unicode, UnicodeText
+from sqlalchemy.types import (
+    BLOB,
+    BOOLEAN,
+    Binary,
+    Boolean,
+    CHAR,
+    CLOB,
+    DATE,
+    DATETIME,
+    DECIMAL,
+    Date,
+    DateTime,
+    FLOAT,
+    Float,
+    INT,
+    Integer,
+    Interval,
+    NCHAR,
+    NUMERIC,
+    Numeric,
+    PickleType,
+    SMALLINT,
+    SmallInteger,
+    String,
+    TEXT,
+    TIME,
+    TIMESTAMP,
+    Text,
+    Time,
+    Unicode,
+    UnicodeText,
+    VARCHAR,
+    )
 
-from sqlalchemy.sql import \
-    func, modifier, text, literal, literal_column, null, alias, \
-    and_, or_, not_, \
-    select, subquery, union, union_all, insert, update, delete, \
-    join, outerjoin, \
-    bindparam, outparam, asc, desc, collate, \
-    except_, except_all, exists, intersect, intersect_all, \
-    between, case, cast, distinct, extract
+from sqlalchemy.sql import (
+    alias,
+    and_,
+    asc,
+    between,
+    bindparam,
+    case,
+    cast,
+    collate,
+    delete,
+    desc,
+    distinct,
+    except_,
+    except_all,
+    exists,
+    extract,
+    func,
+    insert,
+    intersect,
+    intersect_all,
+    join,
+    literal,
+    literal_column,
+    modifier,
+    not_,
+    null,
+    or_,
+    outerjoin,
+    outparam,
+    select,
+    subquery,
+    text,
+    union,
+    union_all,
+    update,
+    )
 
-from sqlalchemy.schema import \
-    MetaData, ThreadLocalMetaData, Table, Column, ForeignKey, \
-    Sequence, Index, ForeignKeyConstraint, PrimaryKeyConstraint, \
-    CheckConstraint, UniqueConstraint, Constraint, \
-    DefaultClause, FetchedValue, PassiveDefault, ColumnDefault, DDL
+from sqlalchemy.schema import (
+    CheckConstraint,
+    Column,
+    ColumnDefault,
+    Constraint,
+    DDL,
+    DefaultClause,
+    FetchedValue,
+    ForeignKey,
+    ForeignKeyConstraint,
+    Index,
+    MetaData,
+    PassiveDefault,
+    PrimaryKeyConstraint,
+    Sequence,
+    Table,
+    ThreadLocalMetaData,
+    UniqueConstraint,
+    )
 
 from sqlalchemy.engine import create_engine, engine_from_config
 
-__all__ = [ name for name, obj in locals().items()
-            if not (name.startswith('_') or inspect.ismodule(obj)) ]
 
+__all__ = sorted(name for name, obj in locals().items()
+                 if not (name.startswith('_') or inspect.ismodule(obj)))
 __version__ = 'svn'
 
 del inspect, sys

lib/sqlalchemy/engine/__init__.py

@@ -51,27 +51,41 @@ url.py
 """
 
 import sqlalchemy.databases
-from sqlalchemy.engine.base import Dialect, ExecutionContext, Compiled, \
-     Connectable, Connection, Transaction, RootTransaction, \
-     NestedTransaction, TwoPhaseTransaction, Engine, RowProxy, \
-     BufferedColumnRow, ResultProxy, BufferedRowResultProxy, \
-     BufferedColumnResultProxy, SchemaIterator, DefaultRunner
+from sqlalchemy.engine.base import (
+    BufferedColumnResultProxy,
+    BufferedColumnRow,
+    BufferedRowResultProxy,
+    Compiled,
+    Connectable,
+    Connection,
+    DefaultRunner,
+    Dialect,
+    Engine,
+    ExecutionContext,
+    NestedTransaction,
+    ResultProxy,
+    RootTransaction,
+    RowProxy,
+    SchemaIterator,
+    Transaction,
+    TwoPhaseTransaction
+    )
 from sqlalchemy.engine import strategies
 from sqlalchemy import util
 
 
-__all__ = [
+__all__ = (
     'engine_descriptors', 'create_engine', 'engine_from_config',
     'Dialect', 'ExecutionContext', 'Compiled', 'Connectable',
     'Connection', 'Transaction', 'RootTransaction', 'NestedTransaction',
     'TwoPhaseTransaction', 'Engine', 'RowProxy', 'BufferedColumnRow',
     'ResultProxy', 'BufferedRowResultProxy', 'BufferedColumnResultProxy',
     'SchemaIterator', 'DefaultRunner',
-    ]
+    )
 
 def engine_descriptors():
     """Provide a listing of all the database implementations supported.
-    
+
     This method will be removed in 0.5.
 
     """

lib/sqlalchemy/orm/__init__.py

@@ -13,17 +13,36 @@ documentation for an overview of how this module is used.
 """
 
 from sqlalchemy.orm import exc
-from sqlalchemy.orm.mapper import \
-     Mapper, _mapper_registry, class_mapper
-from sqlalchemy.orm.interfaces import \
-     EXT_CONTINUE, EXT_STOP, ExtensionOption, InstrumentationManager, \
-     MapperExtension, PropComparator, SessionExtension
-from sqlalchemy.orm.util import \
-     AliasedClass as aliased, join, object_mapper, outerjoin, \
-     polymorphic_union, with_parent
-from sqlalchemy.orm.properties import \
-     BackRef, ColumnProperty, ComparableProperty, CompositeProperty, \
-     PropertyLoader, SynonymProperty
+from sqlalchemy.orm.mapper import (
+     Mapper,
+     _mapper_registry,
+     class_mapper,
+     )
+from sqlalchemy.orm.interfaces import (
+     EXT_CONTINUE,
+     EXT_STOP,
+     ExtensionOption,
+     InstrumentationManager,
+     MapperExtension,
+     PropComparator,
+     SessionExtension,
+     )
+from sqlalchemy.orm.util import (
+     AliasedClass as aliased,
+     join,
+     object_mapper,
+     outerjoin,
+     polymorphic_union,
+     with_parent,
+     )
+from sqlalchemy.orm.properties import (
+     BackRef,
+     ColumnProperty,
+     ComparableProperty,
+     CompositeProperty,
+     PropertyLoader,
+     SynonymProperty,
+     )
 from sqlalchemy.orm import mapper as mapperlib
 from sqlalchemy.orm import strategies
 from sqlalchemy.orm.query import AliasOption, Query

lib/sqlalchemy/orm/dynamic.py

@@ -14,8 +14,9 @@ basic add/delete mutation.
 from sqlalchemy import log, util
 import sqlalchemy.exceptions as sa_exc
 
-from sqlalchemy.orm import attributes, object_session, \
-     util as mapperutil, strategies
+from sqlalchemy.orm import (
+    attributes, object_session, util as mapperutil, strategies,
+    )
 from sqlalchemy.orm.query import Query
 from sqlalchemy.orm.util import has_identity
 

lib/sqlalchemy/orm/mapper.py

@@ -25,12 +25,13 @@ from sqlalchemy.orm import attributes
 from sqlalchemy.orm import exc
 from sqlalchemy.orm import sync
 from sqlalchemy.orm.identity import IdentityManagedState
-from sqlalchemy.orm.interfaces import MapperProperty, EXT_CONTINUE, \
-     PropComparator
-from sqlalchemy.orm.util import \
-     ExtensionCarrier, _INSTRUMENTOR, _class_to_mapper, \
-     _state_has_identity, _state_mapper, class_mapper, \
-     instance_str, state_str
+from sqlalchemy.orm.interfaces import (
+    MapperProperty, EXT_CONTINUE, PropComparator
+    )
+from sqlalchemy.orm.util import (
+     ExtensionCarrier, _INSTRUMENTOR, _class_to_mapper, _state_has_identity,
+     _state_mapper, class_mapper, instance_str, state_str,
+     )
 
 
 __all__ = (

lib/sqlalchemy/orm/properties.py

@@ -15,11 +15,14 @@ from sqlalchemy import sql, util, log
 import sqlalchemy.exceptions as sa_exc
 from sqlalchemy.sql.util import ClauseAdapter, criterion_as_pairs
 from sqlalchemy.sql import operators, expression
-from sqlalchemy.orm import mapper, strategies, attributes, dependency, \
-     object_mapper
+from sqlalchemy.orm import (
+    attributes, dependency, mapper, object_mapper, strategies,
+    )
 from sqlalchemy.orm.util import CascadeOptions, _class_to_mapper, _orm_annotate
-from sqlalchemy.orm.interfaces import StrategizedProperty, PropComparator, \
-     MapperProperty, ONETOMANY, MANYTOONE, MANYTOMANY
+from sqlalchemy.orm.interfaces import (
+    MANYTOMANY, MANYTOONE, MapperProperty, ONETOMANY, PropComparator,
+    StrategizedProperty,
+    )
 
 __all__ = ('ColumnProperty', 'CompositeProperty', 'SynonymProperty',
            'ComparableProperty', 'PropertyLoader', 'BackRef')

lib/sqlalchemy/orm/query.py

@@ -26,10 +26,15 @@ from sqlalchemy import exc as sa_exc
 from sqlalchemy.orm import exc as orm_exc
 from sqlalchemy.sql import util as sql_util
 from sqlalchemy.sql import expression, visitors, operators
-from sqlalchemy.orm import attributes, interfaces, mapper, object_mapper, evaluator
-from sqlalchemy.orm.util import _is_mapped_class, \
-     _is_aliased_class, _entity_descriptor, _entity_info, \
-     _orm_columns, AliasedClass, _orm_selectable, join as orm_join, ORMAdapter
+from sqlalchemy.orm import (
+    attributes, interfaces, mapper, object_mapper, evaluator,
+    )
+from sqlalchemy.orm.util import (
+    AliasedClass, ORMAdapter, _entity_descriptor, _entity_info,
+    _is_aliased_class, _is_mapped_class, _orm_columns, _orm_selectable,
+    join as orm_join,
+    )
+
 
 __all__ = ['Query', 'QueryContext', 'aliased']
 

lib/sqlalchemy/orm/scoping.py

@@ -6,10 +6,12 @@
 
 import sqlalchemy.exceptions as sa_exc
 from sqlalchemy.util import ScopedRegistry, to_list, get_cls_kwargs
-from sqlalchemy.orm import MapperExtension, EXT_CONTINUE, object_session, \
-     class_mapper
+from sqlalchemy.orm import (
+    EXT_CONTINUE, MapperExtension, class_mapper, object_session,
+    )
 from sqlalchemy.orm.session import Session
 
+
 __all__ = ['ScopedSession']
 
 

lib/sqlalchemy/orm/session.py

@@ -12,11 +12,14 @@ import sqlalchemy.exceptions as sa_exc
 import sqlalchemy.orm.attributes
 from sqlalchemy import util, sql, engine
 from sqlalchemy.sql import util as sql_util, expression
-from sqlalchemy.orm import exc, unitofwork, query, attributes, \
-     util as mapperutil, SessionExtension
+from sqlalchemy.orm import (
+    SessionExtension, attributes, exc, query, unitofwork, util as mapperutil,
+    )
 from sqlalchemy.orm.util import object_mapper as _object_mapper
 from sqlalchemy.orm.util import class_mapper as _class_mapper
-from sqlalchemy.orm.util import _state_mapper, _state_has_identity, _class_to_mapper
+from sqlalchemy.orm.util import (
+    _class_to_mapper, _state_has_identity, _state_mapper,
+    )
 from sqlalchemy.orm.mapper import Mapper
 from sqlalchemy.orm.unitofwork import UOWTransaction
 from sqlalchemy.orm import identity

lib/sqlalchemy/orm/strategies.py

@@ -11,8 +11,10 @@ from sqlalchemy import sql, util, log
 from sqlalchemy.sql import util as sql_util
 from sqlalchemy.sql import visitors, expression, operators
 from sqlalchemy.orm import mapper, attributes
-from sqlalchemy.orm.interfaces import LoaderStrategy, StrategizedOption, \
-     MapperOption, PropertyOption, serialize_path, deserialize_path
+from sqlalchemy.orm.interfaces import (
+    LoaderStrategy, StrategizedOption, MapperOption, PropertyOption,
+    serialize_path, deserialize_path
+    )
 from sqlalchemy.orm import session as sessionlib
 from sqlalchemy.orm import util as mapperutil
 

lib/sqlalchemy/sql/__init__.py

@@ -1,2 +1,56 @@
-from sqlalchemy.sql.expression import *
+from sqlalchemy.sql.expression import (
+    Alias,
+    ClauseElement,
+    ColumnCollection,
+    ColumnElement,
+    CompoundSelect,
+    Delete,
+    FromClause,
+    Insert,
+    Join,
+    Select,
+    Selectable,
+    TableClause,
+    Update,
+    alias,
+    and_,
+    asc,
+    between,
+    bindparam,
+    case,
+    cast,
+    collate,
+    column,
+    delete,
+    desc,
+    distinct,
+    except_,
+    except_all,
+    exists,
+    extract,
+    func,
+    insert,
+    intersect,
+    intersect_all,
+    join,
+    literal,
+    literal_column,
+    modifier,
+    not_,
+    null,
+    or_,
+    outerjoin,
+    outparam,
+    select,
+    subquery,
+    table,
+    text,
+    union,
+    union_all,
+    update,
+    )
+
 from sqlalchemy.sql.visitors import ClauseVisitor
+
+
+__all__ = sorted(locals().keys())

lib/sqlalchemy/sql/expression.py

@@ -1,4 +1,4 @@
-# sql.py
+# expression.py
 # Copyright (C) 2005, 2006, 2007, 2008 Michael Bayer mike_mp@zzzcomputing.com
 #
 # This module is part of SQLAlchemy and is released under

lib/sqlalchemy/sql/functions.py

@@ -1,6 +1,7 @@
 from sqlalchemy import types as sqltypes
-from sqlalchemy.sql.expression import _Function, _literal_as_binds, \
-                                      ClauseList, _FigureVisitName
+from sqlalchemy.sql.expression import (
+    ClauseList, _FigureVisitName, _Function, _literal_as_binds,
+    )
 from sqlalchemy.sql import operators
 
 

lib/sqlalchemy/sql/operators.py

@@ -3,10 +3,12 @@
 
 """Defines operators used in SQL expressions."""
 
-from operator import and_, or_, inv, add, mul, sub, div, mod, truediv, \
-     lt, le, ne, gt, ge, eq
+from operator import (
+    and_, or_, inv, add, mul, sub, div, mod, truediv, lt, le, ne, gt, ge, eq
+    )
 from sqlalchemy.util import symbol
 
+
 def from_():
     raise NotImplementedError()
 
@@ -84,40 +86,41 @@ _smallest = symbol('_smallest')
 _largest = symbol('_largest')
 
 _PRECEDENCE = {
-    from_:15,
-    mul:7,
-    div:7,
-    mod:7,
-    add:6,
-    sub:6,
-    concat_op:6,
-    match_op:6,
-    ilike_op:5,
-    notilike_op:5,
-    like_op:5,
-    notlike_op:5,
-    in_op:5,
-    notin_op:5,
-    is_:5,
-    isnot:5,
-    eq:5,
-    ne:5,
-    gt:5,
-    lt:5,
-    ge:5,
-    le:5,
-    between_op:5,
-    distinct_op:5,
-    inv:5,
-    and_:3,
-    or_:2,
-    comma_op:-1,
+    from_: 15,
+    mul: 7,
+    div: 7,
+    mod: 7,
+    add: 6,
+    sub: 6,
+    concat_op: 6,
+    match_op: 6,
+    ilike_op: 5,
+    notilike_op: 5,
+    like_op: 5,
+    notlike_op: 5,
+    in_op: 5,
+    notin_op: 5,
+    is_: 5,
+    isnot: 5,
+    eq: 5,
+    ne: 5,
+    gt: 5,
+    lt: 5,
+    ge: 5,
+    le: 5,
+    between_op: 5,
+    distinct_op: 5,
+    inv: 5,
+    and_: 3,
+    or_: 2,
+    comma_op: -1,
     collate: -2,
-    as_:-1,
-    exists:0,
+    as_: -1,
+    exists: 0,
     _smallest: -1000,
     _largest: 1000
 }
 
 def is_precedent(operator, against):
-    return _PRECEDENCE.get(operator, _PRECEDENCE[_smallest]) <= _PRECEDENCE.get(against, _PRECEDENCE[_largest])
+    return (_PRECEDENCE.get(operator, _PRECEDENCE[_smallest]) <=
+            _PRECEDENCE.get(against, _PRECEDENCE[_largest]))