[SQL-CVS] r1591 - in MetaSQLObject/trunk: . metasqlobject sqlobject tests tests/so

[<sub...@co...>]

Author: ianb
Date: 2006-02-11 02:51:51 -0700 (Sat, 11 Feb 2006)
New Revision: 1591

Added:
   MetaSQLObject/trunk/metasqlobject/classinst.py
   MetaSQLObject/trunk/metasqlobject/events.py
   MetaSQLObject/trunk/sqlobject/
   MetaSQLObject/trunk/sqlobject/__init__.py
   MetaSQLObject/trunk/sqlobject/col.py
   MetaSQLObject/trunk/sqlobject/events.py
   MetaSQLObject/trunk/sqlobject/main.py
   MetaSQLObject/trunk/tests/
   MetaSQLObject/trunk/tests/conftest.py
   MetaSQLObject/trunk/tests/so/
Modified:
   MetaSQLObject/trunk/metasqlobject/declarative.py
   MetaSQLObject/trunk/setup.cfg
   MetaSQLObject/trunk/setup.py
   MetaSQLObject/trunk/tests/so/dbtest.py
   MetaSQLObject/trunk/tests/so/test_auto.py
   MetaSQLObject/trunk/tests/so/test_auto_old.py
   MetaSQLObject/trunk/tests/so/test_create_drop.py
   MetaSQLObject/trunk/tests/so/test_cyclic_reference.py
   MetaSQLObject/trunk/tests/so/test_datetime.py
   MetaSQLObject/trunk/tests/so/test_joins_conditional.py
   MetaSQLObject/trunk/tests/so/test_paste.py
   MetaSQLObject/trunk/tests/so/test_string_id.py
Log:
Intermediate commit while stuff is getting moved around

Added: MetaSQLObject/trunk/metasqlobject/classinst.py
===================================================================
--- MetaSQLObject/trunk/metasqlobject/classinst.py	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/metasqlobject/classinst.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -0,0 +1,37 @@
+__all__ = ['classinstancemethod']
+
+class classinstancemethod(object):
+    """
+    Acts like a class method when called from a class, like an
+    instance method when called by an instance.  The method should
+    take two arguments, 'self' and 'cls'; one of these will be None
+    depending on how the method was called.
+    """
+
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, obj, type=None):
+        return _methodwrapper(self.func, obj=obj, type=type)
+
+class _methodwrapper(object):
+
+    def __init__(self, func, obj, type):
+        self.func = func
+        self.obj = obj
+        self.type = type
+
+    def __call__(self, *args, **kw):
+        assert not kw.has_key('self') and not kw.has_key('cls'), (
+            "You cannot use 'self' or 'cls' arguments to a "
+            "classinstancemethod")
+        return self.func(*((self.obj, self.type) + args), **kw)
+
+    def __repr__(self):
+        if self.obj is None:
+            return ('<bound class method %s.%s>'
+                    % (self.type.__name__, self.func.func_name))
+        else:
+            return ('<bound method %s.%s of %r>'
+                    % (self.type.__name__, self.func.func_name,
+                       self.obj))


Property changes on: MetaSQLObject/trunk/metasqlobject/classinst.py
___________________________________________________________________
Name: svn:eol-style
   + native

Modified: MetaSQLObject/trunk/metasqlobject/declarative.py
===================================================================
--- MetaSQLObject/trunk/metasqlobject/declarative.py	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/metasqlobject/declarative.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -7,39 +7,36 @@
 (So if a class is received, we'll simply instantiate an instance with
 no arguments).
 
-You can provide a variable __unpackargs__ (a list of strings), and if
-the constructor is called with non-keyword arguments they will be
-interpreted as the given keyword arguments.
+You can provide a class variable ``__unpackargs__`` (a list of
+strings), and if the constructor is called with non-keyword arguments
+they will be interpreted as the given keyword arguments.
 
-If __unpackargs__ is ('*', name), then all the arguments will be put
-in a variable by that name.
+If ``__unpackargs__`` is ``('*', name)``, then all the arguments will
+be put in a variable by that name.
 
-You can define a __classinit__(cls, new_attrs) method, which will be
-called when the class is created (including subclasses).  Note: you
-can't use super() in __classinit__ because the class isn't bound to a
-name.  As an analog to __classinit__, Declarative adds
-__instanceinit__ which is called with the same argument (new_attrs).
-This is like __init__, but after __unpackargs__ and other factors have
-been taken into account.
+You can define a ``__classinit__(cls, new_attrs)`` method, which will
+be called when the class is created (including subclasses).  Note: you
+can't use ``super()`` in ``__classinit__`` because the class isn't
+bound to a name.  As an analog to ``__classinit__``, ``Declarative``
+adds ``__instanceinit__`` which is called with the same argument
+(``new_attrs``).  This is like ``__init__``, but applied after
+``__unpackargs__`` and other factors have been taken into account.
 
-If __mutableattributes__ is defined as a sequence of strings, these
-attributes will not be shared between superclasses and their
+If ``__mutableattributes__`` is defined as a sequence of strings,
+these attributes will not be shared between superclasses and their
 subclasses.  E.g., if you have a class variable that contains a list
 and you append to that list, changes to subclasses will effect
-superclasses unless you add the attribute here.
-
-Also defines classinstancemethod, which acts as either a class method
-or an instance method depending on where it is called.
+superclasses unless you add the attribute here.  So any variables
+listed there will be copied (shallowly).
 """
 
 from __future__ import generators
 import threading
-import events
-
-__all__ = ('classinstancemethod', 'DeclarativeMeta', 'Declarative')
-
 import copy
+from classinst import classinstancemethod
 
+__all__ = ('DeclarativeMeta', 'Declarative')
+
 try:
     import itertools
     counter = itertools.count()
@@ -51,55 +48,6 @@
             yield i
     counter = _counter()
 
-class classinstancemethod(object):
-    """
-    Acts like a class method when called from a class, like an
-    instance method when called by an instance.  The method should
-    take two arguments, 'self' and 'cls'; one of these will be None
-    depending on how the method was called.
-    """
-
-    def __init__(self, func):
-        self.func = func
-
-    def __get__(self, obj, type=None):
-        return _methodwrapper(self.func, obj=obj, type=type)
-
-class _methodwrapper(object):
-
-    def __init__(self, func, obj, type):
-        self.func = func
-        self.obj = obj
-        self.type = type
-
-    def __call__(self, *args, **kw):
-        assert not kw.has_key('self') and not kw.has_key('cls'), (
-            "You cannot use 'self' or 'cls' arguments to a "
-            "classinstancemethod")
-        return self.func(*((self.obj, self.type) + args), **kw)
-
-    def __repr__(self):
-        if self.obj is None:
-            return ('<bound class method %s.%s>'
-                    % (self.type.__name__, self.func.func_name))
-        else:
-            return ('<bound method %s.%s of %r>'
-                    % (self.type.__name__, self.func.func_name, self.obj))
-
-def threadSafeMethod(lock):
-    def decorator(fn):
-        def _wrapper(self, *args, **kwargs):
-            lock.acquire()
-            return_value = fn(self, *args, **kwargs)
-            lock.release()
-            return return_value
-        try:
-            _wrapper.func_name = fn.func_name
-        except TypeError:
-            pass
-        return _wrapper
-    return decorator
-
 class DeclarativeMeta(type):
 
     def __new__(meta, class_name, bases, new_attrs):

Copied: MetaSQLObject/trunk/metasqlobject/events.py (from rev 1562, SQLObject/trunk/sqlobject/events.py)
===================================================================
--- SQLObject/trunk/sqlobject/events.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/metasqlobject/events.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -0,0 +1,44 @@
+from weakref import ref
+from UserDict import DictMixin
+
+__all__ = ['EventHub', 'Signal']
+
+class EventHub(DictMixin):
+
+    def __init__(self):
+        self._events = {}
+
+    def copy(self):
+        new = self.__class__()
+        new._events = self._events.copy()
+        return new
+
+    def listen(self, signal, listener, weak=True):
+        if weak:
+            listener = ref(listener)
+        else:
+            listener = lambda l=listener: l
+        self._events.setdefault(signal, []).append(listener)
+
+    def send(self, signal, **kw):
+        for listener in self._events.get(signal, ()):
+            listener(**kw)
+    
+class _Signal(object):
+    """
+    Base event for all SQLObject events.
+
+    In general the sender for these methods is the class, not the
+    instance.
+    """
+
+    def __init__(self, class_name, bases, attrs):
+        self.name = self.__name__ = class_name
+        for name, value in attrs.items():
+            setattr(self, name, value)
+
+    def __repr__(self):
+        return '<Signal:%s>' % (self.name)
+
+Signal = _Signal('Signal', (), {})
+

Modified: MetaSQLObject/trunk/setup.cfg
===================================================================
--- MetaSQLObject/trunk/setup.cfg	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/setup.cfg	2006-02-11 09:51:51 UTC (rev 1591)
@@ -7,7 +7,7 @@
 docs = docs/index.txt
 doc_base = docs/
 dest = docs/html
-modules = metasqlobject
+modules = metasqlobject sqlobject
 title = Meta SQLObject
 mailing_list_url = http://sqlobject.org/community.html
 settings = normal_link_color=#039

Modified: MetaSQLObject/trunk/setup.py
===================================================================
--- MetaSQLObject/trunk/setup.py	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/setup.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -17,7 +17,7 @@
       include_package_data=True,
       zip_safe=False,
       install_requires=[
-          # -*- Extra requirements: -*-
+        'Louie',
       ],
       entry_points="""
       # -*- Entry points: -*-

Added: MetaSQLObject/trunk/sqlobject/__init__.py
===================================================================
--- MetaSQLObject/trunk/sqlobject/__init__.py	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/sqlobject/__init__.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -0,0 +1 @@
+#


Property changes on: MetaSQLObject/trunk/sqlobject/__init__.py
___________________________________________________________________
Name: svn:eol-style
   + native

Added: MetaSQLObject/trunk/sqlobject/col.py
===================================================================
--- MetaSQLObject/trunk/sqlobject/col.py	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/sqlobject/col.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -0,0 +1,28 @@
+from metasqlobject.declarative import Declarative
+
+class Col(Declarative):
+
+    standard_sql_type = None
+    sql_type_parameters = {}
+
+    def _add_sql_type_param(self, **params):
+        if self.sql_type_parameters is self.__class__.sql_type_parameters:
+            self.sql_type_parameters = self.sql_type_parameters.copy()
+        self.sql_type_parameters.update(params)
+
+class StringCol(Col):
+
+    standard_sql_type = 'TEXT'
+    
+    def __init__(self, length=None):
+        if length is not None:
+            self._add_sql_type_param(length=length)
+        
+class IntCol(Col):
+
+    standard_sql_type = 'INT'
+
+class FloatCol(Col):
+
+    standard_sql_type = 'FLOAT'
+


Property changes on: MetaSQLObject/trunk/sqlobject/col.py
___________________________________________________________________
Name: svn:eol-style
   + native

Added: MetaSQLObject/trunk/sqlobject/events.py
===================================================================
--- MetaSQLObject/trunk/sqlobject/events.py	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/sqlobject/events.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -0,0 +1,114 @@
+from metasqlobject.eventhub import Signal
+
+class ClassCreateSignal(Signal):
+    """
+    Signal raised after class creation.  The sender is the superclass
+    (in case of multiple superclasses, the first superclass).  The
+    arguments are ``(new_class_name, bases, new_attrs, post_funcs,
+    early_funcs)``.  ``new_attrs`` is a dictionary and may be modified
+    (but ``new_class_name`` and ``bases`` are immutable).
+    ``post_funcs`` is an initially-empty list that can have callbacks
+    appended to it.
+
+    Note: at the time this event is called, the new class has not yet
+    been created.  The functions in ``post_funcs`` will be called
+    after the class is created, with the single arguments of
+    ``(new_class)``.  Also, ``early_funcs`` will be called at the
+    soonest possible time after class creation (``post_funcs`` is
+    called after the class's ``__classinit__``).
+    """
+
+# @@: Should there be a class reload event?  This would allow modules
+# to be reloaded, possibly.  Or it could even be folded into
+# ClassCreateSignal, since anything that listens to that needs to pay
+# attention to reloads (or else it is probably buggy).
+
+class RowCreateSignal(Signal):
+    """
+    Called before an instance is created, with the class as the
+    sender.  Called with the arguments ``(kwargs, post_funcs)``.
+    There may be a ``connection`` argument.  ``kwargs``may be usefully
+    modified.  ``post_funcs`` is a list of callbacks, intended to have
+    functions appended to it, and are called with the arguments
+    ``(new_instance)``.
+
+    Note: this is not called when an instance is created from an
+    existing database row.
+    """
+
+# @@: An event for getting a row?  But for each row, when doing a
+# select?  For .sync, .syncUpdate, .expire?
+
+class RowDestroySignal(Signal):
+    """
+    Called before an instance is deleted.  Sender is the instance's
+    class.  Arguments are ``(instance)``.  You cannot cancel the delete,
+    but you can raise an exception (which will probably cancel the
+    delete, but also cause an uncaught exception if not expected).
+
+    Note: this is not called when an instance is destroyed through
+    garbage collection.
+
+    @@: Should this allow ``instance`` to be a primary key, so that a
+    row can be deleted without first fetching it?
+    """
+    
+class RowUpdateSignal(Signal):
+    """
+    Called when an instance is updated through a call to ``.set()``.
+    The arguments are ``(instance, kwargs)``.  ``kwargs`` can be
+    modified.  This is run *before* the instance is updated; if you
+    want to look at the current values, simply look at ``instance``.
+    """
+
+class AddColumnSignal(Signal):
+    """
+    Called when a column is added to a class, with arguments ``(cls,
+    connection, column_name, column_definition, changeSchema,
+    post_funcs)``.  This is called *after* the column has been added,
+    and is called for each column after class creation.
+
+    post_funcs are called with ``(cls, so_column_obj)``
+    """
+
+class DeleteColumnSignal(Signal):
+    """
+    Called when a column is removed from a class, with the arguments
+    ``(cls, connection, column_name, so_column_obj, post_funcs)``.
+    Like ``AddColumnSignal`` this is called after the action has been
+    performed, and is called for subclassing (when a column is
+    implicitly removed by setting it to ``None``).
+
+    post_funcs are called with ``(cls, so_column_obj)``
+    """
+
+# @@: Signals for indexes and joins?  These are mostly event consumers,
+# though.
+
+class CreateTableSignal(Signal):
+    """
+    Called when a table is created.  If ``ifNotExists==True`` and the
+    table exists, this event is not called.
+
+    Called with ``(cls, connection, extra_sql, post_funcs)``.
+    ``extra_sql`` is a list (which can be appended to) of extra SQL
+    statements to be run after the table is created.  ``post_funcs``
+    functions are called with ``(cls, connection)`` after the table
+    has been created.  Those functions are *not* called simply when
+    constructing the SQL.
+    """
+
+class DropTableSignal(Signal):
+    """
+    Called when a table is dropped.  If ``ifExists==True`` and the
+    table doesn't exist, this event is not called.
+
+    Called with ``(cls, connection, extra_sql, post_funcs)``.
+    ``post_funcs`` functions are called with ``(cls, connection)``
+    after the table has been dropped.
+    """
+
+__all__ = []
+for name, value in globals().items():
+    if isinstance(value, type) and issubclass(value, Signal):
+        __all__.append(name)


Property changes on: MetaSQLObject/trunk/sqlobject/events.py
___________________________________________________________________
Name: svn:eol-style
   + native

Added: MetaSQLObject/trunk/sqlobject/main.py
===================================================================
--- MetaSQLObject/trunk/sqlobject/main.py	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/sqlobject/main.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -0,0 +1,49 @@
+from metasqlobject.declarative import Declarative
+from sqlapi import sql
+
+class sqlmeta(object):
+
+    _creating = False
+
+    lazy = False
+
+    def __init__(self, instance):
+        self.instance = instance
+
+    #@classmethod
+    def _set_soclass(cls, soclass):
+        cls.soclass = soclass
+
+    _set_soclass = classmethod(_set_soclass)
+
+    def create(self):
+        conn = self.connection
+        sql = sql.Insert(self._values, self.table)
+        
+
+
+class SQLObject(Declarative):
+
+    def __classinit__(cls, new_attrs):
+        if not isinstance(cls.sqlmeta, sqlmeta):
+            new_sqlmeta = type(sqlmeta, (cls.__bases__[0].sqlmeta,),
+                               cls.sqlmeta.__dict__)
+            cls.sqlmeta = new_sqlmeta
+        cls.sqlmeta._set_soclass(cls)
+        
+    def __init__(self, **kw):
+        self.sqlmeta = self.sqlmeta(self)
+        self.sqlmeta._creating = True
+        self.sqlmeta._values = {}
+        for name, value in kw:
+            if hasattr(self, name):
+                setattr(self, name, value)
+            else:
+                raise TypeError(
+                    "%s() called with unknown keyword %s"
+                    % (self.__class__.__name__, name))
+
+        if not self.sqlmeta.lazy:
+            self.sqlmeta.create()
+    
+    


Property changes on: MetaSQLObject/trunk/sqlobject/main.py
___________________________________________________________________
Name: svn:eol-style
   + native

Added: MetaSQLObject/trunk/tests/conftest.py
===================================================================
--- MetaSQLObject/trunk/tests/conftest.py	2006-02-10 21:04:09 UTC (rev 1590)
+++ MetaSQLObject/trunk/tests/conftest.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -0,0 +1,4 @@
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+import pkg_resources
+pkg_resources.require('MetaSQLObject')


Property changes on: MetaSQLObject/trunk/tests/conftest.py
___________________________________________________________________
Name: svn:eol-style
   + native

Copied: MetaSQLObject/trunk/tests/so (from rev 1562, SQLObject/trunk/sqlobject/tests)

Modified: MetaSQLObject/trunk/tests/so/dbtest.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/dbtest.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/dbtest.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -43,169 +43,20 @@
     '-limitSelect' : 'mssql'
     }
 
+def setConnection(conn):
+    if isinstance(conn, basestring):
+        conn = sqlobject.connectionForURI(conn)
+    sqlobject.sqlhub.processConnection = conn
 
-def setupClass(soClasses, force=False):
-    """
-    Makes sure the classes have a corresponding and correct table.
-    This won't recreate the table if it already exists.  It will check
-    that the table is properly defined (in case you change your table
-    definition).
-
-    You can provide a single class or a list of classes; if a list
-    then classes will be created in the order you provide, and
-    destroyed in the opposite order.  So if class A depends on class
-    B, then do setupClass([B, A]) and B won't be destroyed or cleared
-    until after A is destroyed or cleared.
-
-    If force is true, then the database will be recreated no matter
-    what.
-    """
-    global hub
+def setupClass(soClasses):
     if not isinstance(soClasses, (list, tuple)):
         soClasses = [soClasses]
-    connection = getConnection()
-    for soClass in soClasses:
-        ## This would be an alternate way to register connections...
-        #try:
-        #    hub
-        #except NameError:
-        #    hub = sqlobject.dbconnection.ConnectionHub()
-        #soClass._connection = hub
-        #hub.threadConnection = connection
-        #hub.processConnection = connection
-        soClass._connection = connection
-    installOrClear(soClasses, force=force)
-    return soClasses
+    reversed = soClasses[:]
+    for class_ in reversed:
+        class_.dropTable(ifExists=True, cascade=True)
+    for class_ in soClasses:
+        class_.createTable()
 
-installedDBFilename = os.path.join(getcwd(), 'dbs_data.tmp')
-
-installedDBTracker = sqlobject.connectionForURI(
-    'sqlite:///' + installedDBFilename)
-
-def getConnection(**kw):
-    name = getConnectionURI()
-    conn = sqlobject.connectionForURI(name, **kw)
-    if conftest.option.show_sql:
-        conn.debug = True
-    if conftest.option.show_sql_output:
-        conn.debugOutput = True
-    return conn
-
-def getConnectionURI():
-    name = conftest.option.Database
-    if conftest.connectionShortcuts.has_key(name):
-        name = conftest.connectionShortcuts[name]
-    return name
-
-try:
-    connection = getConnection()
-except Exception, e:
-    # At least this module should be importable...
-    print >> sys.stderr, (
-        "Could not open database: %s" % e)
-    
-
-class InstalledTestDatabase(sqlobject.SQLObject):
-    """
-    This table is set up in SQLite (always, regardless of --Database) and
-    tracks what tables have been set up in the 'real' database.  This
-    way we don't keep recreating the tables over and over when there
-    are multiple tests that use a table.
-    """
-
-    _connection = installedDBTracker
-    tableName = sqlobject.StringCol(notNull=True)
-    createSQL = sqlobject.StringCol(notNull=True)
-    connectionURI = sqlobject.StringCol(notNull=True)
-
-    def installOrClear(cls, soClasses, force=False):
-        cls.setup()
-        reversed = list(soClasses)[:]
-        reversed.reverse()
-        # If anything needs to be dropped, they all must be dropped
-        # But if we're forcing it, then we'll always drop
-        if force:
-            any_drops = True
-        else:
-            any_drops = False
-        for soClass in reversed:
-            table = soClass.sqlmeta.table
-            if not soClass._connection.tableExists(table):
-                continue
-            items = list(cls.selectBy(
-                tableName=table,
-                connectionURI=soClass._connection.uri()))
-            if items:
-                instance = items[0]
-                sql = instance.createSQL
-            else:
-                sql = None
-            newSQL, constraints = soClass.createTableSQL()
-            if sql != newSQL:
-                if sql is not None:
-                    instance.destroySelf()
-                any_drops = True
-                break
-        for soClass in reversed:
-            if soClass._connection.tableExists(soClass.sqlmeta.table):
-                if any_drops:
-                    cls.drop(soClass)
-                else:
-                    cls.clear(soClass)
-        for soClass in soClasses:
-            table = soClass.sqlmeta.table
-            if not soClass._connection.tableExists(table):
-                cls.install(soClass)
-    installOrClear = classmethod(installOrClear)
-
-    def install(cls, soClass):
-        """
-        Creates the given table in its database.
-        """
-        sql = getattr(soClass, soClass._connection.dbName + 'Create',
-                      None)
-        all_extra = []
-        if sql:
-            soClass._connection.query(sql)
-        else:
-            sql, extra_sql = soClass.createTableSQL()
-            soClass.createTable(applyConstraints=False)
-            all_extra.extend(extra_sql)
-        cls(tableName=soClass.sqlmeta.table,
-            createSQL=sql,
-            connectionURI=soClass._connection.uri())
-        for extra_sql in all_extra:
-            soClass._connection.query(extra_sql)
-    install = classmethod(install)
-
-    def drop(cls, soClass):
-        """
-        Drops a the given table from its database
-        """
-        sql = getattr(soClass, soClass._connection.dbName + 'Drop', None)
-        if sql:
-            soClass._connection.query(sql)
-        else:
-            soClass.dropTable()
-    drop = classmethod(drop)
-
-    def clear(cls, soClass):
-        """
-        Removes all the rows from a table.
-        """
-        soClass.clearTable()
-    clear = classmethod(clear)
-
-    def setup(cls):
-        """
-        This sets up *this* table.
-        """
-        if not cls._connection.tableExists(cls.sqlmeta.table):
-            cls.createTable()
-    setup = classmethod(setup)
-
-installOrClear = InstalledTestDatabase.installOrClear
-
 class Dummy(object):
 
     """
@@ -255,7 +106,7 @@
     return results
 
 def supports(feature):
-    dbName = connection.dbName
+    dbName = sqlobject.sqlhub.getConnection().dbName
     support = supportsMatrix.get('+' + feature, None)
     notSupport = supportsMatrix.get('-' + feature, None)
     if support is not None and dbName in support.split():
@@ -294,6 +145,6 @@
     sqlobject.main.warnings_level = None
     sqlobject.main.exception_level = 0
 
-__all__ = ['getConnection', 'getConnectionURI', 'setupClass', 'Dummy', 'raises',
+__all__ = ['setupClass', 'Dummy', 'raises',
            'd', 'inserts', 'supports', 'deprecated_module',
            'setup_module', 'teardown_module']

Modified: MetaSQLObject/trunk/tests/so/test_auto.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/test_auto.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/test_auto.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -135,14 +135,16 @@
     mssqlDrop = sybaseDrop
 
     def setup_method(self, meth):
-        conn = getConnection()
+        conn = sqlhub.getConnection()
+        if conn.tableExists('auto_test'):
+            conn.dropTable('auto_test')
         dbName = conn.dbName
         creator = getattr(self, dbName + 'Create', None)
         if creator:
             conn.query(creator)
 
     def teardown_method(self, meth):
-        conn = getConnection()
+        conn = sqlhub.getConnection()
         dbName = conn.dbName
         dropper = getattr(self, dbName + 'Drop', None)
         if dropper:
@@ -152,7 +154,7 @@
         if not supports('fromDatabase'):
             return
         class AutoTest(SQLObject):
-            _connection = getConnection()
+            _connection = sqlhub.getConnection()
             class sqlmeta(sqlmeta):
                 idName = 'auto_id'
                 fromDatabase = True

Modified: MetaSQLObject/trunk/tests/so/test_auto_old.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/test_auto_old.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/test_auto_old.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -28,8 +28,7 @@
 class TestPeople:
 
     def setup_method(self, meth):
-        setupClass(OldPerson, force=True)
-        setupClass(OldPhone, force=True)
+        setupClass([OldPerson, OldPhone])
         for n in ['jane', 'tim', 'bob', 'jake']:
             OldPerson(name=n)
         for p in ['555-555-5555', '555-394-2930',
@@ -137,14 +136,14 @@
     DROP TABLE old_auto_test
     """
     def setup_method(self, meth):
-        conn = getConnection()
+        conn = sqlhub.getConnection()
         dbName = conn.dbName
         creator = getattr(self, dbName + 'Create', None)
         if creator:
             conn.query(creator)
 
     def teardown_method(self, meth):
-        conn = getConnection()
+        conn = sqlhub.getConnection()
         dbName = conn.dbName
         dropper = getattr(self, dbName + 'Drop', None)
         if dropper:
@@ -154,7 +153,7 @@
         if not supports('fromDatabase'):
             return
         class OldAutoTest(SQLObject):
-            _connection = getConnection()
+            _connection = sqlhub.getConnection()
             class sqlmeta(sqlmeta):
                 idName = 'auto_id'
                 fromDatabase = True

Modified: MetaSQLObject/trunk/tests/so/test_create_drop.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/test_create_drop.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/test_create_drop.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -12,7 +12,7 @@
     blobcol = BLOBCol()
 
 def test_create_drop():
-    conn = getConnection()
+    conn = sqlhub.getConnection()
     TestCreateDrop.setConnection(conn)
     TestCreateDrop.dropTable(ifExists=True)
     assert not conn.tableExists(TestCreateDrop.sqlmeta.table)

Modified: MetaSQLObject/trunk/tests/so/test_cyclic_reference.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/test_cyclic_reference.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/test_cyclic_reference.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -24,7 +24,7 @@
     fkeya = ForeignKey('TestCyclicReferenceA') 
 
 def test_cyclic_reference():
-    conn = getConnection()
+    conn = sqlhub.getConnection()
     TestCyclicReferenceA.setConnection(conn)
     TestCyclicReferenceB.setConnection(conn)
     TestCyclicReferenceA.dropTable(ifExists=True, cascade=True)

Modified: MetaSQLObject/trunk/tests/so/test_datetime.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/test_datetime.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/test_datetime.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -44,7 +44,7 @@
     from mx.DateTime import now, Time
 
     dateFormat = None # use default
-    if getConnection().dbName == "sqlite":
+    if sqlhub.getConnection().dbName == "sqlite":
         from sqlobject.sqlite.sqliteconnection import using_sqlite2
         if using_sqlite2: # PySQLite2 returns full date/time for a date
             dateFormat = "%Y-%m-%d %H:%M:%S"

Modified: MetaSQLObject/trunk/tests/so/test_joins_conditional.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/test_joins_conditional.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/test_joins_conditional.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -26,7 +26,7 @@
     join = LEFTJOIN("table1", "table2")
     assert str(join) == "table1 LEFT JOIN table2"
     join = LEFTJOINOn("table1", "table2", "tabl1.col1 = table2.col2")
-    assert getConnection().sqlrepr(join) == "table1 LEFT JOIN table2 ON tabl1.col1 = table2.col2"
+    assert sqlhub.getConnection().sqlrepr(join) == "table1 LEFT JOIN table2 ON tabl1.col1 = table2.col2"
 
 def test_2select_syntax():
     setup()

Modified: MetaSQLObject/trunk/tests/so/test_paste.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/test_paste.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/test_paste.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -26,7 +26,7 @@
 
 def makestack(abort=False, begin=False, fail=False, **kw):
     app = makeapp(abort=abort, begin=begin, fail=fail)
-    app = make_middleware(app, {}, database=getConnectionURI(), **kw)
+    app = make_middleware(app, {}, database=sqlhub.getConnection(), **kw)
     return app
 
 def runapp(**kw):
@@ -43,11 +43,11 @@
 
 def setup():
     setupClass(NameOnly)
-    getConnection().query('DELETE FROM name_only')
+    sqlhub.getConnection().query('DELETE FROM name_only')
     NameOnly._connection = sqlhub
 
 def names():
-    names = [n.name for n in NameOnly.select(connection=getConnection())]
+    names = [n.name for n in NameOnly.select(connection=sqlhub.getConnection())]
     names.sort()
     return names
 

Modified: MetaSQLObject/trunk/tests/so/test_string_id.py
===================================================================
--- SQLObject/trunk/sqlobject/tests/test_string_id.py	2006-02-03 19:08:46 UTC (rev 1562)
+++ MetaSQLObject/trunk/tests/so/test_string_id.py	2006-02-11 09:51:51 UTC (rev 1591)
@@ -8,7 +8,7 @@
     name = StringCol()
 
 def test_string_id():
-    conn = getConnection()
+    conn = sqlhub.getConnection()
     TestStringID.setConnection(conn)
     TestStringID.dropTable(ifExists=True)
     assert not conn.tableExists(TestStringID.sqlmeta.table)