merge 0.6 series to trunk.

5 files changed, 50 insertions, 17 deletions

diff --git a/lib/sqlalchemy/ext/compiler.py b/lib/sqlalchemy/ext/compiler.py
index 0e3db00e0..05df8d2be 100644
--- a/lib/sqlalchemy/ext/compiler.py
+++ b/lib/sqlalchemy/ext/compiler.py
@@ -33,7 +33,7 @@ Produces::
 Compilers can also be made dialect-specific.  The appropriate compiler will be invoked
 for the dialect in use::
 
-    from sqlalchemy.schema import DDLElement  # this is a SQLA 0.6 construct
+    from sqlalchemy.schema import DDLElement
 
     class AlterColumn(DDLElement):
 
@@ -45,16 +45,16 @@ for the dialect in use::
     def visit_alter_column(element, compiler, **kw):
         return "ALTER COLUMN %s ..." % element.column.name
 
-    @compiles(AlterColumn, 'postgres')
+    @compiles(AlterColumn, 'postgresql')
     def visit_alter_column(element, compiler, **kw):
         return "ALTER TABLE %s ALTER COLUMN %s ..." % (element.table.name, element.column.name)
 
-The second ``visit_alter_table`` will be invoked when any ``postgres`` dialect is used.
+The second ``visit_alter_table`` will be invoked when any ``postgresql`` dialect is used.
 
 The ``compiler`` argument is the :class:`~sqlalchemy.engine.base.Compiled` object
 in use.  This object can be inspected for any information about the in-progress 
 compilation, including ``compiler.dialect``, ``compiler.statement`` etc.
-The :class:`~sqlalchemy.sql.compiler.SQLCompiler` and :class:`~sqlalchemy.sql.compiler.DDLCompiler` (DDLCompiler is 0.6. only)
+The :class:`~sqlalchemy.sql.compiler.SQLCompiler` and :class:`~sqlalchemy.sql.compiler.DDLCompiler`
 both include a ``process()`` method which can be used for compilation of embedded attributes::
 
     class InsertFromSelect(ClauseElement):
diff --git a/lib/sqlalchemy/ext/declarative.py b/lib/sqlalchemy/ext/declarative.py
index 07974cacc..c37211ac3 100644
--- a/lib/sqlalchemy/ext/declarative.py
+++ b/lib/sqlalchemy/ext/declarative.py
@@ -396,7 +396,7 @@ only intended as an optional syntax for the regular usage of mappers and Table
 objects.  A typical application setup using :func:`~sqlalchemy.orm.scoped_session` might look
 like::
 
-    engine = create_engine('postgres://scott:tiger@localhost/test')
+    engine = create_engine('postgresql://scott:tiger@localhost/test')
     Session = scoped_session(sessionmaker(autocommit=False,
                                           autoflush=False,
                                           bind=engine))
diff --git a/lib/sqlalchemy/ext/orderinglist.py b/lib/sqlalchemy/ext/orderinglist.py
index a5d60bf82..8e63ed1c2 100644
--- a/lib/sqlalchemy/ext/orderinglist.py
+++ b/lib/sqlalchemy/ext/orderinglist.py
@@ -240,7 +240,8 @@ class OrderingList(list):
     _raw_append = collection.adds(1)(_raw_append)
 
     def insert(self, index, entity):
-        self[index:index] = [entity]
+        super(OrderingList, self).insert(index, entity)
+        self._reorder()
 
     def remove(self, entity):
         super(OrderingList, self).remove(entity)
@@ -253,7 +254,15 @@ class OrderingList(list):
 
     def __setitem__(self, index, entity):
         if isinstance(index, slice):
-            for i in range(index.start or 0, index.stop or 0, index.step or 1):
+            step = index.step or 1
+            start = index.start or 0
+            if start < 0:
+                start += len(self)
+            stop = index.stop or len(self)
+            if stop < 0:
+                stop += len(self)
+            
+            for i in xrange(start, stop, step):
                 self.__setitem__(i, entity[i])
         else:
             self._order_entity(index, entity, True)
@@ -263,6 +272,7 @@ class OrderingList(list):
         super(OrderingList, self).__delitem__(index)
         self._reorder()
 
+    # Py2K
     def __setslice__(self, start, end, values):
         super(OrderingList, self).__setslice__(start, end, values)
         self._reorder()
@@ -270,7 +280,8 @@ class OrderingList(list):
     def __delslice__(self, start, end):
         super(OrderingList, self).__delslice__(start, end)
         self._reorder()
-
+    # end Py2K
+    
     for func_name, func in locals().items():
         if (util.callable(func) and func.func_name == func_name and
             not func.__doc__ and hasattr(list, func_name)):
diff --git a/lib/sqlalchemy/ext/serializer.py b/lib/sqlalchemy/ext/serializer.py
index b62ee0ce6..fd456e385 100644
--- a/lib/sqlalchemy/ext/serializer.py
+++ b/lib/sqlalchemy/ext/serializer.py
@@ -43,10 +43,26 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.util import pickle
 import re
 import base64
-from cStringIO import StringIO
+# Py3K
+#from io import BytesIO as byte_buffer
+# Py2K
+from cStringIO import StringIO as byte_buffer
+# end Py2K
+
+# Py3K
+#def b64encode(x):
+#    return base64.b64encode(x).decode('ascii')
+#def b64decode(x):
+#    return base64.b64decode(x.encode('ascii'))
+# Py2K
+b64encode = base64.b64encode
+b64decode = base64.b64decode
+# end Py2K
 
 __all__ = ['Serializer', 'Deserializer', 'dumps', 'loads']
 
+
+
 def Serializer(*args, **kw):
     pickler = pickle.Pickler(*args, **kw)
         
@@ -55,9 +71,9 @@ def Serializer(*args, **kw):
         if isinstance(obj, QueryableAttribute):
             cls = obj.impl.class_
             key = obj.impl.key
-            id = "attribute:" + key + ":" + base64.b64encode(pickle.dumps(cls))
+            id = "attribute:" + key + ":" + b64encode(pickle.dumps(cls))
         elif isinstance(obj, Mapper) and not obj.non_primary:
-            id = "mapper:" + base64.b64encode(pickle.dumps(obj.class_))
+            id = "mapper:" + b64encode(pickle.dumps(obj.class_))
         elif isinstance(obj, Table):
             id = "table:" + str(obj)
         elif isinstance(obj, Column) and isinstance(obj.table, Table):
@@ -96,10 +112,10 @@ def Deserializer(file, metadata=None, scoped_session=None, engine=None):
             type_, args = m.group(1, 2)
             if type_ == 'attribute':
                 key, clsarg = args.split(":")
-                cls = pickle.loads(base64.b64decode(clsarg))
+                cls = pickle.loads(b64decode(clsarg))
                 return getattr(cls, key)
             elif type_ == "mapper":
-                cls = pickle.loads(base64.b64decode(args))
+                cls = pickle.loads(b64decode(args))
                 return class_mapper(cls)
             elif type_ == "table":
                 return metadata.tables[args]
@@ -116,13 +132,13 @@ def Deserializer(file, metadata=None, scoped_session=None, engine=None):
     return unpickler
 
 def dumps(obj):
-    buf = StringIO()
+    buf = byte_buffer()
     pickler = Serializer(buf)
     pickler.dump(obj)
     return buf.getvalue()
     
 def loads(data, metadata=None, scoped_session=None, engine=None):
-    buf = StringIO(data)
+    buf = byte_buffer(data)
     unpickler = Deserializer(buf, metadata, scoped_session, engine)
     return unpickler.load()
     
diff --git a/lib/sqlalchemy/ext/sqlsoup.py b/lib/sqlalchemy/ext/sqlsoup.py
index b3f2de743..6eef4657c 100644
--- a/lib/sqlalchemy/ext/sqlsoup.py
+++ b/lib/sqlalchemy/ext/sqlsoup.py
@@ -86,7 +86,7 @@ Full query documentation
 Get, filter, filter_by, order_by, limit, and the rest of the
 query methods are explained in detail in the `SQLAlchemy documentation`__.
 
-__ http://www.sqlalchemy.org/docs/04/ormtutorial.html#datamapping_querying
+__ http://www.sqlalchemy.org/docs/05/ormtutorial.html#datamapping_querying
 
 
 Modifying objects
@@ -447,9 +447,11 @@ def _selectable_name(selectable):
 def class_for_table(selectable, **mapper_kwargs):
     selectable = expression._clause_element_as_expr(selectable)
     mapname = 'Mapped' + _selectable_name(selectable)
+    # Py2K
     if isinstance(mapname, unicode): 
         engine_encoding = selectable.metadata.bind.dialect.encoding 
         mapname = mapname.encode(engine_encoding)
+    # end Py2K
     if isinstance(selectable, Table):
         klass = TableClassType(mapname, (object,), {})
     else:
@@ -543,10 +545,14 @@ class SqlSoup:
     def entity(self, attr, schema=None):
         try:
             t = self._cache[attr]
-        except KeyError:
+        except KeyError, ke:
             table = Table(attr, self._metadata, autoload=True, schema=schema or self.schema)
             if not table.primary_key.columns:
+                # Py3K
+                #raise PKNotFoundError('table %r does not have a primary key defined [columns: %s]' % (attr, ','.join(table.c.keys()))) from ke
+                # Py2K
                 raise PKNotFoundError('table %r does not have a primary key defined [columns: %s]' % (attr, ','.join(table.c.keys())))
+                # end Py2K
             if table.columns:
                 t = class_for_table(table)
             else: