Remove unused imports, typo and light formatting tweaks.

Fixed comparison of _UnaryExpressions

30 files changed, 93 insertions, 94 deletions

diff --git a/lib/sqlalchemy/ansisql.py b/lib/sqlalchemy/ansisql.py
index d39d8ea08..d26d11c4d 100644
--- a/lib/sqlalchemy/ansisql.py
+++ b/lib/sqlalchemy/ansisql.py
@@ -10,9 +10,10 @@ Contains default implementations for the abstract objects in the sql
 module.
 """
 
-from sqlalchemy import schema, sql, engine, util, sql_util, exceptions
+import string, re, sets, operator
+
+from sqlalchemy import schema, sql, engine, util, exceptions
 from  sqlalchemy.engine import default
-import string, re, sets, random, operator
 
 ANSI_FUNCS = sets.ImmutableSet(['CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
                                 'CURRENT_USER', 'LOCALTIME', 'LOCALTIMESTAMP',
diff --git a/lib/sqlalchemy/databases/firebird.py b/lib/sqlalchemy/databases/firebird.py
index 0d6bd3360..525e4788d 100644
--- a/lib/sqlalchemy/databases/firebird.py
+++ b/lib/sqlalchemy/databases/firebird.py
@@ -5,7 +5,7 @@
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
 
-import sys, StringIO, string, types, warnings
+import warnings
 
 from sqlalchemy import util, sql, schema, ansisql, exceptions
 import sqlalchemy.engine.default as default
diff --git a/lib/sqlalchemy/databases/information_schema.py b/lib/sqlalchemy/databases/information_schema.py
index 54c47b6f4..d8cad4200 100644
--- a/lib/sqlalchemy/databases/information_schema.py
+++ b/lib/sqlalchemy/databases/information_schema.py
@@ -1,28 +1,24 @@
 import sqlalchemy.sql as sql
-import sqlalchemy.engine as engine
-import sqlalchemy.schema as schema
-import sqlalchemy.ansisql as ansisql
-import sqlalchemy.types as sqltypes
 import sqlalchemy.exceptions as exceptions
-from sqlalchemy import *
-from sqlalchemy.ansisql import *
+from sqlalchemy import select, MetaData, Table, Column, String, Integer
+from sqlalchemy.schema import PassiveDefault, ForeignKeyConstraint
 
 ischema = MetaData()
 
-schemata = schema.Table("schemata", ischema,
+schemata = Table("schemata", ischema,
     Column("catalog_name", String),
     Column("schema_name", String),
     Column("schema_owner", String),
     schema="information_schema")
 
-tables = schema.Table("tables", ischema,
+tables = Table("tables", ischema,
     Column("table_catalog", String),
     Column("table_schema", String),
     Column("table_name", String),
     Column("table_type", String),
     schema="information_schema")
 
-columns = schema.Table("columns", ischema,
+columns = Table("columns", ischema,
     Column("table_schema", String),
     Column("table_name", String),
     Column("column_name", String),
@@ -35,21 +31,21 @@ columns = schema.Table("columns", ischema,
     Column("column_default", Integer),
     schema="information_schema")
     
-constraints = schema.Table("table_constraints", ischema,
+constraints = Table("table_constraints", ischema,
     Column("table_schema", String),
     Column("table_name", String),
     Column("constraint_name", String),
     Column("constraint_type", String),
     schema="information_schema")
 
-column_constraints = schema.Table("constraint_column_usage", ischema,
+column_constraints = Table("constraint_column_usage", ischema,
     Column("table_schema", String),
     Column("table_name", String),
     Column("column_name", String),
     Column("constraint_name", String),
     schema="information_schema")
 
-pg_key_constraints = schema.Table("key_column_usage", ischema,
+pg_key_constraints = Table("key_column_usage", ischema,
     Column("table_schema", String),
     Column("table_name", String),
     Column("column_name", String),
@@ -57,7 +53,7 @@ pg_key_constraints = schema.Table("key_column_usage", ischema,
     Column("ordinal_position", Integer),
     schema="information_schema")
 
-#mysql_key_constraints = schema.Table("key_column_usage", ischema,
+#mysql_key_constraints = Table("key_column_usage", ischema,
 #    Column("table_schema", String),
 #    Column("table_name", String),
 #    Column("column_name", String),
@@ -69,7 +65,7 @@ pg_key_constraints = schema.Table("key_column_usage", ischema,
 
 key_constraints = pg_key_constraints
 
-ref_constraints = schema.Table("referential_constraints", ischema,
+ref_constraints = Table("referential_constraints", ischema,
     Column("constraint_catalog", String),
     Column("constraint_schema", String),
     Column("constraint_name", String),
@@ -97,7 +93,7 @@ class ISchema(object):
             try:
                 gen_tbl = globals()['gen_'+name]
             except KeyError:
-                raise ArgumentError('information_schema table %s not found' % name)
+                raise exceptions.ArgumentError('information_schema table %s not found' % name)
             self.cache[name] = gen_tbl.toengine(self.engine)
         return self.cache[name]
 
@@ -145,7 +141,7 @@ def reflecttable(connection, table, ischema_names):
         colargs= []
         if default is not None:
             colargs.append(PassiveDefault(sql.text(default)))
-        table.append_column(schema.Column(name, coltype, nullable=nullable, *colargs))
+        table.append_column(Column(name, coltype, nullable=nullable, *colargs))
     
     if not found_table:
         raise exceptions.NoSuchTableError(table.name)
@@ -186,10 +182,10 @@ def reflecttable(connection, table, ischema_names):
             if current_schema == referred_schema:
                 referred_schema = table.schema
             if referred_schema is not None:
-                schema.Table(referred_table, table.metadata, autoload=True, schema=referred_schema, autoload_with=connection)
+                Table(referred_table, table.metadata, autoload=True, schema=referred_schema, autoload_with=connection)
                 refspec = ".".join([referred_schema, referred_table, referred_column])
             else:
-                schema.Table(referred_table, table.metadata, autoload=True, autoload_with=connection)
+                Table(referred_table, table.metadata, autoload=True, autoload_with=connection)
                 refspec = ".".join([referred_table, referred_column])
             if constrained_column not in fk[0]:
                 fk[0].append(constrained_column)
diff --git a/lib/sqlalchemy/databases/informix.py b/lib/sqlalchemy/databases/informix.py
index d3f397118..43de41b78 100644
--- a/lib/sqlalchemy/databases/informix.py
+++ b/lib/sqlalchemy/databases/informix.py
@@ -5,12 +5,9 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
+import datetime, warnings
 
-import sys, StringIO, string , random, warnings
-import datetime
-from decimal import Decimal
-
-from sqlalchemy import util, sql, engine, schema, ansisql, exceptions, pool
+from sqlalchemy import sql, schema, ansisql, exceptions, pool
 import sqlalchemy.engine.default as default
 import sqlalchemy.types as sqltypes
 
@@ -426,9 +423,9 @@ class InfoCompiler(ansisql.ANSICompiler):
         except:
             li = [ c for c in list.clauses ]
         if list.parens:
-            self.strings[list] = "(" + string.join([s for s in [self.strings[c] for c in li] if s is not None ], ', ') + ")"
+            self.strings[list] = "(" + ', '.join([s for s in [self.strings[c] for c in li] if s is not None ]) + ")"
         else:
-            self.strings[list] = string.join([s for s in [self.strings[c] for c in li] if s is not None], ', ')
+            self.strings[list] = ', '.join([s for s in [self.strings[c] for c in li] if s is not None])
 
 class InfoSchemaGenerator(ansisql.ANSISchemaGenerator):
     def get_column_specification(self, column, first_pk=False):
diff --git a/lib/sqlalchemy/databases/mssql.py b/lib/sqlalchemy/databases/mssql.py
index 3f181c5bb..c7fd01f43 100644
--- a/lib/sqlalchemy/databases/mssql.py
+++ b/lib/sqlalchemy/databases/mssql.py
@@ -39,9 +39,9 @@ Known issues / TODO:
   
 """
 
-import sys, StringIO, string, types, re, datetime, random, warnings
+import datetime, random, warnings
 
-from sqlalchemy import sql, engine, schema, ansisql, exceptions
+from sqlalchemy import sql, schema, ansisql, exceptions
 import sqlalchemy.types as sqltypes
 from sqlalchemy.engine import default
     
@@ -838,7 +838,7 @@ class MSSQLCompiler(ansisql.ANSICompiler):
 
     def label_select_column(self, select, column):
         if isinstance(column, sql._Function):
-            return co.label(co.name + "_" + hex(random.randint(0, 65535))[2:])        
+            return column.label(column.name + "_" + hex(random.randint(0, 65535))[2:])        
         else:
             return super(MSSQLCompiler, self).label_select_column(select, column)
 
diff --git a/lib/sqlalchemy/databases/oracle.py b/lib/sqlalchemy/databases/oracle.py
index 82388ef87..cc9fd3d9a 100644
--- a/lib/sqlalchemy/databases/oracle.py
+++ b/lib/sqlalchemy/databases/oracle.py
@@ -5,9 +5,9 @@
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
 
-import sys, StringIO, string, re, warnings, operator
+import re, warnings, operator
 
-from sqlalchemy import util, sql, engine, schema, ansisql, exceptions, logging
+from sqlalchemy import util, sql, schema, ansisql, exceptions, logging
 from sqlalchemy.engine import default, base
 import sqlalchemy.types as sqltypes
 
diff --git a/lib/sqlalchemy/databases/postgres.py b/lib/sqlalchemy/databases/postgres.py
index 80a56a3ca..cd486e282 100644
--- a/lib/sqlalchemy/databases/postgres.py
+++ b/lib/sqlalchemy/databases/postgres.py
@@ -4,9 +4,9 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
-import datetime, string, types, re, random, warnings, operator
+import re, random, warnings, operator
 
-from sqlalchemy import util, sql, schema, ansisql, exceptions
+from sqlalchemy import sql, schema, ansisql, exceptions
 from sqlalchemy.engine import base, default
 import sqlalchemy.types as sqltypes
 from sqlalchemy.databases import information_schema as ischema
diff --git a/lib/sqlalchemy/databases/sqlite.py b/lib/sqlalchemy/databases/sqlite.py
index f544e359a..531db4475 100644
--- a/lib/sqlalchemy/databases/sqlite.py
+++ b/lib/sqlalchemy/databases/sqlite.py
@@ -5,9 +5,9 @@
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
 
-import sys, StringIO, string, types, re
+import re
 
-from sqlalchemy import sql, engine, schema, ansisql, exceptions, pool, PassiveDefault
+from sqlalchemy import schema, ansisql, exceptions, pool, PassiveDefault
 import sqlalchemy.engine.default as default
 import sqlalchemy.types as sqltypes
 import datetime,time, warnings
diff --git a/lib/sqlalchemy/engine/__init__.py b/lib/sqlalchemy/engine/__init__.py
index 5a4865de0..50d03ea91 100644
--- a/lib/sqlalchemy/engine/__init__.py
+++ b/lib/sqlalchemy/engine/__init__.py
@@ -48,7 +48,6 @@ The package is represented among several individual modules, including:
 from sqlalchemy import databases
 from sqlalchemy.engine.base import *
 from sqlalchemy.engine import strategies
-import re
 
 def engine_descriptors():
     """Provide a listing of all the database implementations supported.
diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py
index ace6f8754..9beb08826 100644
--- a/lib/sqlalchemy/engine/base.py
+++ b/lib/sqlalchemy/engine/base.py
@@ -1127,7 +1127,7 @@ class ResultProxy(object):
                 rec = (type, type.dialect_impl(self.dialect), i)
 
                 if rec[0] is None:
-                    raise DBAPIError("None for metadata " + colname)
+                    raise exceptions.DBAPIError("None for metadata " + colname)
                 if self.__props.setdefault(colname.lower(), rec) is not rec:
                     self.__props[colname.lower()] = (type, ResultProxy.AmbiguousColumn(colname), 0)
                 self.__keys.append(colname)
diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py
index 7f89d1eb5..f87551c2a 100644
--- a/lib/sqlalchemy/engine/default.py
+++ b/lib/sqlalchemy/engine/default.py
@@ -6,8 +6,8 @@
 
 """Provide default implementations of per-dialect sqlalchemy.engine classes"""
 
-from sqlalchemy import schema, exceptions, util, sql, types
-import StringIO, sys, re
+from sqlalchemy import schema, exceptions, sql, types
+import sys, re
 from sqlalchemy.engine import base
 
 
@@ -162,7 +162,7 @@ class DefaultDialect(base.Dialect):
             # to appropriate character upon compilation
             self.positional = True
         else:
-            raise DBAPIError("Unsupported paramstyle '%s'" % self._paramstyle)
+            raise exceptions.DBAPIError("Unsupported paramstyle '%s'" % self._paramstyle)
 
     def _get_ischema(self):
         if self._ischema is None:
diff --git a/lib/sqlalchemy/engine/strategies.py b/lib/sqlalchemy/engine/strategies.py
index 5618f6e0e..0c59ee8eb 100644
--- a/lib/sqlalchemy/engine/strategies.py
+++ b/lib/sqlalchemy/engine/strategies.py
@@ -8,7 +8,7 @@ object which will add itself to the list of available strategies.
 """
 
 
-from sqlalchemy.engine import base, default, threadlocal, url
+from sqlalchemy.engine import base, threadlocal, url
 from sqlalchemy import util, exceptions
 from sqlalchemy import pool as poollib
 
@@ -182,4 +182,4 @@ class MockEngineStrategy(EngineStrategy):
         def execute(self, object, *multiparams, **params):
             raise NotImplementedError()
 
-MockEngineStrategy()
\ No newline at end of file
+MockEngineStrategy()
diff --git a/lib/sqlalchemy/engine/threadlocal.py b/lib/sqlalchemy/engine/threadlocal.py
index a67ab750b..b6ba54ea5 100644
--- a/lib/sqlalchemy/engine/threadlocal.py
+++ b/lib/sqlalchemy/engine/threadlocal.py
@@ -1,6 +1,5 @@
-from sqlalchemy import schema, exceptions, util, sql, types
-import StringIO, sys, re
-from sqlalchemy.engine import base, default
+from sqlalchemy import util
+from sqlalchemy.engine import base
 
 """Provide a thread-local transactional wrapper around the root Engine class.
 
diff --git a/lib/sqlalchemy/ext/activemapper.py b/lib/sqlalchemy/ext/activemapper.py
index eed38e3c0..fa32a5fc3 100644
--- a/lib/sqlalchemy/ext/activemapper.py
+++ b/lib/sqlalchemy/ext/activemapper.py
@@ -1,7 +1,6 @@
-from sqlalchemy             import join, ThreadLocalMetaData, util, Integer
-from sqlalchemy             import and_, or_
+from sqlalchemy             import ThreadLocalMetaData, util, Integer
 from sqlalchemy             import Table, Column, ForeignKey
-from sqlalchemy.orm         import class_mapper, relation, mapper, create_session
+from sqlalchemy.orm         import class_mapper, relation, create_session
                                    
 from sqlalchemy.ext.sessioncontext import SessionContext
 from sqlalchemy.ext.assignmapper import assign_mapper
diff --git a/lib/sqlalchemy/ext/sqlsoup.py b/lib/sqlalchemy/ext/sqlsoup.py
index 90399b7b5..3cffdd098 100644
--- a/lib/sqlalchemy/ext/sqlsoup.py
+++ b/lib/sqlalchemy/ext/sqlsoup.py
@@ -312,7 +312,6 @@ Boring tests here.  Nothing of real expository value.
 from sqlalchemy import *
 from sqlalchemy.orm import *
 from sqlalchemy.ext.sessioncontext import SessionContext
-from sqlalchemy.ext.assignmapper import assign_mapper
 from sqlalchemy.exceptions import *
 
 
diff --git a/lib/sqlalchemy/mods/selectresults.py b/lib/sqlalchemy/mods/selectresults.py
index ac8de9b06..25bfa2840 100644
--- a/lib/sqlalchemy/mods/selectresults.py
+++ b/lib/sqlalchemy/mods/selectresults.py
@@ -1,4 +1,4 @@
-from sqlalchemy.ext.selectresults import *
+from sqlalchemy.ext.selectresults import SelectResultsExt
 from sqlalchemy.orm.mapper import global_extensions
 
 def install_plugin():
diff --git a/lib/sqlalchemy/orm/__init__.py b/lib/sqlalchemy/orm/__init__.py
index 4a8c94d7b..9e9615635 100644
--- a/lib/sqlalchemy/orm/__init__.py
+++ b/lib/sqlalchemy/orm/__init__.py
@@ -15,16 +15,20 @@ from sqlalchemy.orm.mapper import Mapper, object_mapper, class_mapper, mapper_re
 from sqlalchemy.orm.interfaces import SynonymProperty, MapperExtension, EXT_PASS, ExtensionOption
 from sqlalchemy.orm.properties import PropertyLoader, ColumnProperty, CompositeProperty, BackRef
 from sqlalchemy.orm import mapper as mapperlib
-from sqlalchemy.orm import collections
+from sqlalchemy.orm import collections, strategies
 from sqlalchemy.orm.query import Query
 from sqlalchemy.orm.util import polymorphic_union
 from sqlalchemy.orm.session import Session as create_session
 from sqlalchemy.orm.session import object_session, attribute_manager
 
-__all__ = ['relation', 'column_property', 'composite', 'backref', 'eagerload', 'lazyload', 'noload', 'deferred', 'defer', 'undefer', 'undefer_group', 'extension',
-        'mapper', 'clear_mappers', 'compile_mappers', 'class_mapper', 'object_mapper', 'MapperExtension', 'Query',
-        'polymorphic_union', 'create_session', 'synonym', 'contains_alias', 'contains_eager', 'EXT_PASS', 'object_session'
-        ]
+__all__ = ['relation', 'column_property', 'composite', 'backref', 'eagerload',
+           'lazyload', 'noload', 'deferred', 'defer', 'undefer',
+           'undefer_group', 'extension', 'mapper', 'clear_mappers',
+           'compile_mappers', 'class_mapper', 'object_mapper',
+           'MapperExtension', 'Query', 'polymorphic_union', 'create_session',
+           'synonym', 'contains_alias', 'contains_eager', 'EXT_PASS',
+           'object_session'
+           ]
 
 def relation(*args, **kwargs):
     """Provide a relationship of a primary Mapper to a secondary Mapper.
diff --git a/lib/sqlalchemy/orm/attributes.py b/lib/sqlalchemy/orm/attributes.py
index dfc025bf2..e583504d1 100644
--- a/lib/sqlalchemy/orm/attributes.py
+++ b/lib/sqlalchemy/orm/attributes.py
@@ -4,11 +4,12 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
-from sqlalchemy import util, sql
+import weakref
+
+from sqlalchemy import util
 from sqlalchemy.orm import util as orm_util, interfaces, collections
 from sqlalchemy.orm.mapper import class_mapper
 from sqlalchemy import logging, exceptions
-import weakref
 
 
 PASSIVE_NORESULT = object()
diff --git a/lib/sqlalchemy/orm/collections.py b/lib/sqlalchemy/orm/collections.py
index 4a7ba0ad6..f51ea3b31 100644
--- a/lib/sqlalchemy/orm/collections.py
+++ b/lib/sqlalchemy/orm/collections.py
@@ -95,10 +95,10 @@ The owning object and InstrumentedCollectionAttribute are also reachable
 through the adapter, allowing for some very sophisticated behavior.
 """
 
+import copy, inspect, sys, weakref
+
 from sqlalchemy import exceptions, schema, util as sautil
 from sqlalchemy.orm import mapper
-import copy, sys, warnings, weakref
-import new
 
 try:
     from threading import Lock
@@ -739,7 +739,7 @@ def _instrument_membership_mutator(method, before, argument, after):
                 executor = getattr(args[0], '_sa_adapter', None)
 
             if before and executor:
-                getattr(executor, op)(value, initiator)
+                getattr(executor, before)(value, initiator)
 
             if not after or not executor:
                 return method(*args, **kw)
diff --git a/lib/sqlalchemy/orm/mapper.py b/lib/sqlalchemy/orm/mapper.py
index eb69fb32c..712f7b90a 100644
--- a/lib/sqlalchemy/orm/mapper.py
+++ b/lib/sqlalchemy/orm/mapper.py
@@ -4,12 +4,12 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
-from sqlalchemy import sql, schema, util, exceptions, logging
+from sqlalchemy import sql, util, exceptions, logging
 from sqlalchemy import sql_util as sqlutil
 from sqlalchemy.orm import util as mapperutil
 from sqlalchemy.orm.util import ExtensionCarrier
 from sqlalchemy.orm import sync
-from sqlalchemy.orm.interfaces import MapperProperty, MapperOption, OperationContext, EXT_PASS, MapperExtension, SynonymProperty
+from sqlalchemy.orm.interfaces import MapperProperty, EXT_PASS, MapperExtension, SynonymProperty
 import weakref, warnings, operator
 
 __all__ = ['Mapper', 'class_mapper', 'object_mapper', 'mapper_registry']
@@ -25,10 +25,13 @@ global_extensions = []
 # column
 NO_ATTRIBUTE = object()
 
-
 # lock used to synchronize the "mapper compile" step
 _COMPILE_MUTEX = util.threading.Lock()
 
+# initialize these two lazily
+attribute_manager = None
+ColumnProperty = None
+
 class Mapper(object):
     """Define the correlation of class attributes to database table
     columns.
diff --git a/lib/sqlalchemy/orm/properties.py b/lib/sqlalchemy/orm/properties.py
index 99148cf61..010413c64 100644
--- a/lib/sqlalchemy/orm/properties.py
+++ b/lib/sqlalchemy/orm/properties.py
@@ -16,7 +16,7 @@ from sqlalchemy.orm import mapper, sync, strategies, attributes, dependency
 from sqlalchemy.orm import session as sessionlib
 from sqlalchemy.orm import util as mapperutil
 import operator
-from sqlalchemy.orm.interfaces import *
+from sqlalchemy.orm.interfaces import StrategizedProperty, PropComparator
 
 __all__ = ['ColumnProperty', 'CompositeProperty', 'PropertyLoader', 'BackRef']
 
diff --git a/lib/sqlalchemy/orm/query.py b/lib/sqlalchemy/orm/query.py
index 12ca8ac03..d487db574 100644
--- a/lib/sqlalchemy/orm/query.py
+++ b/lib/sqlalchemy/orm/query.py
@@ -4,18 +4,16 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
-from sqlalchemy import sql, util, exceptions, sql_util, logging, schema
-from sqlalchemy.orm import mapper, class_mapper, object_mapper
+from sqlalchemy import sql, util, exceptions, sql_util, logging
+from sqlalchemy.orm import mapper, object_mapper
 from sqlalchemy.orm.interfaces import OperationContext
 import operator
 
 __all__ = ['Query', 'QueryContext', 'SelectionContext']
 
 class Query(object):
-    """Encapsulates the object-fetching operations provided by Mappers.
+    """Encapsulates the object-fetching operations provided by Mappers."""
     
-    """
-
     def __init__(self, class_or_mapper, session=None, entity_name=None):
         if isinstance(class_or_mapper, type):
             self.mapper = mapper.class_mapper(class_or_mapper, entity_name=entity_name)
@@ -250,7 +248,7 @@ class Query(object):
     def filter_by(self, *args, **kwargs):
         """apply the given filtering criterion to the query and return the newly resulting ``Query``."""
 
-        import properties
+        #import properties
         
         if len(args) > 1:
             raise exceptions.ArgumentError("filter_by() takes either zero positional arguments, or one scalar or list argument indicating a property search path.")
@@ -954,7 +952,7 @@ class Query(object):
     def execute(self, clauseelement, params=None, *args, **kwargs):
         """DEPRECATED.  use query.from_statement().all()"""
 
-        return self._select_statement(statement, params, **kwargs)
+        return self._select_statement(clauseelement, params, **kwargs)
 
     def select_statement(self, statement, **params):
         """DEPRECATED.  Use query.from_statement(statement)"""
@@ -964,7 +962,7 @@ class Query(object):
     def select_text(self, text, **params):
         """DEPRECATED.  Use query.from_statement(statement)"""
 
-        return self._select_statement(statement, params)
+        return self._select_statement(text, params)
 
     def _select_statement(self, statement, params=None, **kwargs):
         q = self.from_statement(statement)
diff --git a/lib/sqlalchemy/orm/session.py b/lib/sqlalchemy/orm/session.py
index 097c6eecb..d41eac2b5 100644
--- a/lib/sqlalchemy/orm/session.py
+++ b/lib/sqlalchemy/orm/session.py
@@ -4,12 +4,12 @@
 # This module is part of SQLAlchemy and is released under
 # the MIT License: http://www.opensource.org/licenses/mit-license.php
 
+import weakref
+
 from sqlalchemy import util, exceptions, sql, engine
-from sqlalchemy.orm import unitofwork, query
+from sqlalchemy.orm import unitofwork, query, util as mapperutil
 from sqlalchemy.orm.mapper import object_mapper as _object_mapper
 from sqlalchemy.orm.mapper import class_mapper as _class_mapper
-import weakref
-import sqlalchemy
 
 class SessionTransaction(object):
     """Represents a Session-level Transaction.
@@ -730,6 +730,7 @@ def object_session(obj):
         return _sessions.get(hashkey)
     return None
 
+# Lazy initialization to avoid circular imports
 unitofwork.object_session = object_session
 from sqlalchemy.orm import mapper
 mapper.attribute_manager = attribute_manager
diff --git a/lib/sqlalchemy/orm/strategies.py b/lib/sqlalchemy/orm/strategies.py
index c581b27c0..4597e6d72 100644
--- a/lib/sqlalchemy/orm/strategies.py
+++ b/lib/sqlalchemy/orm/strategies.py
@@ -6,9 +6,9 @@
 
 """sqlalchemy.orm.interfaces.LoaderStrategy implementations, and related MapperOptions."""
 
-from sqlalchemy import sql, schema, util, exceptions, sql_util, logging
+from sqlalchemy import sql, util, exceptions, sql_util, logging
 from sqlalchemy.orm import mapper, attributes
-from sqlalchemy.orm.interfaces import *
+from sqlalchemy.orm.interfaces import LoaderStrategy, StrategizedOption, MapperOption, PropertyOption
 from sqlalchemy.orm import session as sessionlib
 from sqlalchemy.orm import util as mapperutil
 
@@ -269,7 +269,7 @@ class LazyLoader(AbstractRelationLoader):
 
         # determine if our "lazywhere" clause is the same as the mapper's
         # get() clause.  then we can just use mapper.get()
-        from sqlalchemy.orm import query
+        #from sqlalchemy.orm import query
         self.use_get = not self.uselist and self.mapper._get_clause.compare(self.lazywhere)
         if self.use_get:
             self.logger.info(str(self.parent_property) + " will use query.get() to optimize instance loads")
diff --git a/lib/sqlalchemy/orm/unitofwork.py b/lib/sqlalchemy/orm/unitofwork.py
index b42e9a941..46770b521 100644
--- a/lib/sqlalchemy/orm/unitofwork.py
+++ b/lib/sqlalchemy/orm/unitofwork.py
@@ -19,14 +19,16 @@ new, dirty, or deleted and provides the capability to flush all those
 changes at once.
 """
 
-from sqlalchemy import util, logging, topological
+from sqlalchemy import util, logging, topological, exceptions
 from sqlalchemy.orm import attributes, interfaces
 from sqlalchemy.orm import util as mapperutil
-from sqlalchemy.orm.mapper import object_mapper, class_mapper
-from sqlalchemy.exceptions import *
+from sqlalchemy.orm.mapper import object_mapper
 import StringIO
 import weakref
 
+# Load lazily
+object_session = None
+
 class UOWEventHandler(interfaces.AttributeExtension):
     """An event handler added to all class attributes which handles
     session operations.
@@ -116,7 +118,7 @@ class UnitOfWork(object):
     def _validate_obj(self, obj):
         if (hasattr(obj, '_instance_key') and not self.identity_map.has_key(obj._instance_key)) or \
             (not hasattr(obj, '_instance_key') and obj not in self.new):
-            raise InvalidRequestError("Instance '%s' is not attached or pending within this session" % repr(obj))
+            raise exceptions.InvalidRequestError("Instance '%s' is not attached or pending within this session" % repr(obj))
 
     def _is_valid(self, obj):
         if (hasattr(obj, '_instance_key') and not self.identity_map.has_key(obj._instance_key)) or \
@@ -142,7 +144,7 @@ class UnitOfWork(object):
         """register the given object as 'new' (i.e. unsaved) within this unit of work."""
 
         if hasattr(obj, '_instance_key'):
-            raise InvalidRequestError("Object '%s' already has an identity - it can't be registered as new" % repr(obj))
+            raise exceptions.InvalidRequestError("Object '%s' already has an identity - it can't be registered as new" % repr(obj))
         if obj not in self.new:
             self.new.add(obj)
             obj._sa_insert_order = len(self.new)
diff --git a/lib/sqlalchemy/pool.py b/lib/sqlalchemy/pool.py
index c3a317c3f..e9297f5a4 100644
--- a/lib/sqlalchemy/pool.py
+++ b/lib/sqlalchemy/pool.py
@@ -13,7 +13,7 @@ automatically, based on module type and connect arguments, simply by
 calling regular DBAPI connect() methods.
 """
 
-import weakref, string, time, sys, traceback
+import weakref, time
 try:
     import cPickle as pickle
 except:
diff --git a/lib/sqlalchemy/schema.py b/lib/sqlalchemy/schema.py
index 20160b0bf..7004094aa 100644
--- a/lib/sqlalchemy/schema.py
+++ b/lib/sqlalchemy/schema.py
@@ -19,7 +19,7 @@ objects as well as the visitor interface, so that the schema package
 
 from sqlalchemy import sql, types, exceptions,util, databases
 import sqlalchemy
-import copy, re, string
+import re, string
 
 __all__ = ['SchemaItem', 'Table', 'Column', 'ForeignKey', 'Sequence', 'Index', 'ForeignKeyConstraint',
             'PrimaryKeyConstraint', 'CheckConstraint', 'UniqueConstraint', 'DefaultGenerator', 'Constraint',
diff --git a/lib/sqlalchemy/sql.py b/lib/sqlalchemy/sql.py
index fe8167bfe..7677aab9c 100644
--- a/lib/sqlalchemy/sql.py
+++ b/lib/sqlalchemy/sql.py
@@ -24,9 +24,9 @@ are less guaranteed to stay the same in future releases.
 
 """
 
-from sqlalchemy import util, exceptions, logging
+from sqlalchemy import util, exceptions
 from sqlalchemy import types as sqltypes
-import string, re, sets, operator
+import re, operator
 
 __all__ = ['AbstractDialect', 'Alias', 'ClauseElement', 'ClauseParameters',
            'ClauseVisitor', 'ColumnCollection', 'ColumnElement',
@@ -2157,10 +2157,10 @@ class _UnaryExpression(ColumnElement):
         return self.element,
 
     def compare(self, other):
-        """Compare this ``_UnaryClause`` against the given ``ClauseElement``."""
+        """Compare this ``_UnaryExpression`` against the given ``ClauseElement``."""
 
         return (
-            isinstance(other, _UnaryClause) and self.operator == other.operator and
+            isinstance(other, _UnaryExpression) and self.operator == other.operator and
             self.modifier == other.modifier and 
             self.element.compare(other.element)
         )
diff --git a/lib/sqlalchemy/topological.py b/lib/sqlalchemy/topological.py
index bad71293e..56c8cb46e 100644
--- a/lib/sqlalchemy/topological.py
+++ b/lib/sqlalchemy/topological.py
@@ -42,7 +42,6 @@ nature - very tricky to reproduce and track down, particularly before
 I realized this characteristic of the algorithm.
 """
 
-import string, StringIO
 from sqlalchemy import util
 from sqlalchemy.exceptions import CircularDependencyError
 
@@ -68,7 +67,7 @@ class _Node(object):
             str(self.item) + \
             (self.cycles is not None and (" (cycles: " + repr([x for x in self.cycles]) + ")") or "") + \
             "\n" + \
-            string.join([n.safestr(indent + 1) for n in self.children], '')
+            ''.join([n.safestr(indent + 1) for n in self.children])
 
     def __repr__(self):
         return "%s" % (str(self.item))
diff --git a/lib/sqlalchemy/types.py b/lib/sqlalchemy/types.py
index 6e59ac16e..06720fd66 100644
--- a/lib/sqlalchemy/types.py
+++ b/lib/sqlalchemy/types.py
@@ -11,7 +11,6 @@ __all__ = [ 'TypeEngine', 'TypeDecorator', 'NullTypeEngine',
         'SMALLINT', 'DATE', 'TIME','Interval'
             ]
 
-from sqlalchemy import util, exceptions
 import inspect
 import datetime as dt
 try:
@@ -19,6 +18,8 @@ try:
 except:
     import pickle
 
+from sqlalchemy import exceptions
+
 class AbstractType(object):
     def __init__(self, *args, **kwargs):
         pass