sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/versioning/__init__.py

@@ -0,0 +1,120 @@
+from datetime import datetime
+from sqlobject import col, events, SQLObject, AND
+
+
+class Version(SQLObject):
+    def restore(self):
+        values = self.sqlmeta.asDict()
+        del values['id']
+        del values['masterID']
+        del values['dateArchived']
+        for _col in self.extraCols:
+            del values[_col]
+        self.masterClass.get(self.masterID).set(**values)
+
+    def nextVersion(self):
+        version = self.select(
+            AND(self.q.masterID == self.masterID, self.q.id > self.id),
+            orderBy=self.q.id)
+        if version.count():
+            return version[0]
+        else:
+            return self.master
+
+    def getChangedFields(self):
+        next = self.nextVersion()
+        columns = self.masterClass.sqlmeta.columns
+        fields = []
+        for column in columns:
+            if column not in ["dateArchived", "id", "masterID"]:
+                if getattr(self, column) != getattr(next, column):
+                    fields.append(column.title())
+
+        return fields
+
+    @classmethod
+    def select(cls, clause=None, *args, **kw):
+        if not getattr(cls, '_connection', None):
+            cls._connection = cls.masterClass._connection
+        return super(Version, cls).select(clause, *args, **kw)
+
+    def __getattr__(self, attr):
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        else:
+            return getattr(self.master, attr)
+
+
+def getColumns(columns, cls):
+    for column, defi in cls.sqlmeta.columnDefinitions.items():
+        if column.endswith("ID") and isinstance(defi, col.ForeignKey):
+            column = column[:-2]
+
+        # remove incompatible constraints
+        kwds = dict(defi._kw)
+        for kw in ["alternateID", "unique"]:
+            if kw in kwds:
+                del kwds[kw]
+        columns[column] = defi.__class__(**kwds)
+
+    # ascend heirarchy
+    if cls.sqlmeta.parentClass:
+        getColumns(columns, cls.sqlmeta.parentClass)
+
+
+class Versioning(object):
+    def __init__(self, extraCols=None):
+        if extraCols:
+            self.extraCols = extraCols
+        else:
+            self.extraCols = {}
+        pass
+
+    def __addtoclass__(self, soClass, name):
+        self.name = name
+        self.soClass = soClass
+
+        attrs = {'dateArchived': col.DateTimeCol(default=datetime.now),
+                 'master': col.ForeignKey(self.soClass.__name__),
+                 'masterClass': self.soClass,
+                 'extraCols': self.extraCols
+                 }
+
+        getColumns(attrs, self.soClass)
+
+        attrs.update(self.extraCols)
+
+        self.versionClass = type(self.soClass.__name__ + 'Versions',
+                                 (Version,),
+                                 attrs)
+
+        if '_connection' in self.soClass.__dict__:
+            self.versionClass._connection = \
+                self.soClass.__dict__['_connection']
+
+        events.listen(self.createTable,
+                      soClass, events.CreateTableSignal)
+        events.listen(self.rowUpdate, soClass,
+                      events.RowUpdateSignal)
+
+    def createVersionTable(self, cls, conn):
+        self.versionClass.createTable(ifNotExists=True, connection=conn)
+
+    def createTable(self, soClass, connection, extra_sql, post_funcs):
+        assert soClass is self.soClass
+        post_funcs.append(self.createVersionTable)
+
+    def rowUpdate(self, instance, kwargs):
+        if instance.childName and instance.childName != self.soClass.__name__:
+            return  # if you want your child class versioned, version it
+
+        values = instance.sqlmeta.asDict()
+        del values['id']
+        values['masterID'] = instance.id
+        self.versionClass(connection=instance._connection, **values)
+
+    def __get__(self, obj, type=None):
+        if obj is None:
+            return self
+        return self.versionClass.select(
+            self.versionClass.q.masterID == obj.id, connection=obj._connection)

sqlobject/versioning/test/test_version.py

@@ -0,0 +1,183 @@
+from sqlobject import ForeignKey, IntCol, SQLObject, StringCol
+from sqlobject.inheritance import InheritableSQLObject
+from sqlobject.versioning import Versioning
+from sqlobject.tests.dbtest import setupClass
+
+
+class MyClass(SQLObject):
+    name = StringCol()
+    versions = Versioning()
+
+
+class Base(InheritableSQLObject):
+    name = StringCol()
+    so_value = IntCol(default=0)
+    versions = Versioning()
+
+
+class Child(Base):
+    toy = StringCol()
+
+
+class Government(InheritableSQLObject):
+    name = StringCol()
+
+
+class Monarchy(Government):
+    monarch = StringCol()
+    versions = Versioning()
+
+
+class VChild(Base):
+    weapon = StringCol()
+    versions = Versioning()
+
+
+class HasForeign(SQLObject):
+    foreign = ForeignKey("Base")
+    versions = Versioning()
+
+
+def _set_extra():
+    return "read all about it"
+
+
+class Extra(SQLObject):
+    name = StringCol()
+    versions = Versioning(
+        extraCols={'extra': StringCol(default=_set_extra())})
+
+
+class HasAltId(SQLObject):
+    name = StringCol()
+    altid = IntCol(alternateID=True)
+    versions = Versioning()
+
+
+def setup():
+    classes = [MyClass, Base, Child, Government,
+               Monarchy, VChild, Extra, HasAltId]
+    if hasattr(HasForeign, "_connection"):
+        classes.insert(0, HasForeign)
+    else:
+        classes.append(HasForeign)
+    for cls in classes:
+        if hasattr(cls, 'versions') and getattr(cls, "_connection", None) and \
+                cls._connection.tableExists(cls.sqlmeta.table):
+            setupClass(cls.versions.versionClass)
+        setupClass(cls)
+        if hasattr(cls, 'versions'):
+            setupClass(cls.versions.versionClass)
+            for version in cls.versions.versionClass.select():
+                version.destroySelf()
+
+
+def test_versioning():
+    # the simple case
+    setup()
+    mc = MyClass(name='fleem')
+    mc.set(name='morx')
+    assert len(list(mc.versions)) == 1
+    assert mc.versions[0].name == "fleem"
+
+    assert len(list(MyClass.select())) == 1
+
+
+def test_inheritable_versioning():
+    setup()
+
+    # base versioned, child unversioned
+    base = Base(name='fleem')
+    base.set(name='morx')
+    assert len(list(base.versions)) == 1
+    assert base.versions[0].name == "fleem"
+    assert len(list(Base.select())) == 1
+
+    child = Child(name='child', toy='nintendo')
+    child.set(name='teenager', toy='guitar')
+    assert len(list(child.versions)) == 0
+
+    # child versioned, base unversioned
+    government = Government(name='canada')
+    assert not hasattr(government, 'versions')
+
+    monarchy = Monarchy(name='UK', monarch='king george iv')
+    assert len(list(monarchy.versions)) == 0
+    monarchy.set(name='queen elisabeth ii')
+    assert len(list(monarchy.versions)) == 1
+    assert monarchy.versions[0].name == "UK"
+    assert len(list(Monarchy.select())) == 1
+
+    # both parent and child versioned
+    num_base_versions = len(list(base.versions))
+    vchild = VChild(name='kid', weapon='slingshot')
+    vchild.set(name='toon', weapon='dynamite')
+    assert len(list(base.versions)) == num_base_versions
+    assert len(list(vchild.versions)) == 1
+    # test setting using setattr directly rather than .set
+    vchild.name = "newname"
+    assert len(list(vchild.versions)) == 2
+
+
+def test_restore():
+    setup()
+    base = Base(name='fleem')
+    base.set(name='morx')
+    assert base.name == "morx"
+    base.versions[0].restore()
+    assert base.name == "fleem"
+
+    monarchy = Monarchy(name='USA', monarch='Emperor Norton I')
+    monarchy.set(name='morx')
+    assert monarchy.name == "morx"
+    monarchy.versions[0].restore()
+    assert monarchy.name == "USA"
+    assert monarchy.monarch == "Emperor Norton I"
+
+    extra = Extra(name='fleem')
+    extra.set(name='morx')
+    assert extra.name == "morx"
+    extra.versions[0].restore()
+    assert extra.name == "fleem"
+
+
+def test_next():
+    setup()
+    base = Base(name='first', so_value=1)
+    base.set(name='second')
+    base.set(name='third', so_value=2)
+    version = base.versions[0]
+    assert version.nextVersion() == base.versions[1]
+    assert version.nextVersion().nextVersion() == base
+
+
+def test_get_changed():
+    setup()
+    base = Base(name='first', so_value=1)
+    base.set(name='second')
+    base.set(name='third', so_value=2)
+    assert base.versions[0].getChangedFields() == ['Name']
+    assert sorted(base.versions[1].getChangedFields()) == ['Name', 'So_Value']
+
+
+def test_foreign_keys():
+    setup()
+    base1 = Base(name='first', so_value=1)
+    base2 = Base(name='first', so_value=1)
+    has_foreign = HasForeign(foreign=base1)
+    has_foreign.foreign = base2
+    assert has_foreign.versions[0].foreign == base1
+
+
+def test_extra():
+    setup()
+    extra = Extra(name='title')
+    extra.name = 'new'
+    assert extra.versions[0].extra == 'read all about it'
+    assert sorted(extra.versions[0].getChangedFields()) == ['Name']
+
+
+def test_altid():
+    setup()
+    extra = HasAltId(name="fleem", altid=5)
+    extra.name = "morx"

sqlobject/views.py

@@ -0,0 +1,151 @@
+from .main import SQLObject
+from .sqlbuilder import AND, Alias, ColumnAS, LEFTJOINOn, \
+    NoDefault, SQLCall, SQLConstant, SQLObjectField, SQLObjectTable, SQLOp, \
+    Select, sqlrepr
+
+
+class ViewSQLObjectField(SQLObjectField):
+    def __init__(self, alias, *arg):
+        SQLObjectField.__init__(self, *arg)
+        self.alias = alias
+
+    def __sqlrepr__(self, db):
+        return self.alias + "." + self.fieldName
+
+    def tablesUsedImmediate(self):
+        return [self.tableName]
+
+
+class ViewSQLObjectTable(SQLObjectTable):
+    FieldClass = ViewSQLObjectField
+
+    def __getattr__(self, attr):
+        if attr == 'sqlmeta':
+            raise AttributeError
+        return SQLObjectTable.__getattr__(self, attr)
+
+    def _getattrFromID(self, attr):
+        return self.FieldClass(self.soClass.sqlmeta.alias, self.tableName,
+                               'id', attr, self.soClass, None)
+
+    def _getattrFromColumn(self, column, attr):
+        return self.FieldClass(self.soClass.sqlmeta.alias, self.tableName,
+                               column.name, attr, self.soClass, column)
+
+
+class ViewSQLObject(SQLObject):
+    """
+    A SQLObject class that derives all it's values from other SQLObject
+    classes. Columns on subclasses should use SQLBuilder constructs for dbName,
+    and sqlmeta should specify:
+
+    * idName as a SQLBuilder construction
+    * clause as SQLBuilder clause for specifying join conditions
+      or other restrictions
+    * table as an optional alternate name for the class alias
+
+    See test_views.py for simple examples.
+    """
+
+    def __classinit__(cls, new_attrs):
+        SQLObject.__classinit__(cls, new_attrs)
+        # like is_base
+        if cls.__name__ != 'ViewSQLObject':
+            dbName = hasattr(cls, '_connection') and \
+                (cls._connection and cls._connection.dbName) or None
+
+            if getattr(cls.sqlmeta, 'table', None):
+                cls.sqlmeta.alias = cls.sqlmeta.table
+            else:
+                cls.sqlmeta.alias = \
+                    cls.sqlmeta.style.pythonClassToDBTable(cls.__name__)
+            alias = cls.sqlmeta.alias
+            columns = [ColumnAS(cls.sqlmeta.idName, 'id')]
+            # {sqlrepr-key: [restriction, *aggregate-column]}
+            aggregates = {'': [None]}
+            inverseColumns = dict(
+                [(y, x) for x, y in cls.sqlmeta.columns.items()])
+            for col in cls.sqlmeta.columnList:
+                n = inverseColumns[col]
+                ascol = ColumnAS(col.dbName, n)
+                if isAggregate(col.dbName):
+                    restriction = getattr(col, 'aggregateClause', None)
+                    if restriction:
+                        restrictkey = sqlrepr(restriction, dbName)
+                        aggregates[restrictkey] = \
+                            aggregates.get(restrictkey, [restriction]) + \
+                            [ascol]
+                    else:
+                        aggregates[''].append(ascol)
+                else:
+                    columns.append(ascol)
+
+            metajoin = getattr(cls.sqlmeta, 'join', NoDefault)
+            clause = getattr(cls.sqlmeta, 'clause', NoDefault)
+            select = Select(columns,
+                            distinct=True,
+                            # @@ LDO check if this really mattered
+                            # for performance
+                            # @@ Postgres (and MySQL?) extension!
+                            # distinctOn=cls.sqlmeta.idName,
+                            join=metajoin,
+                            clause=clause)
+
+            aggregates = aggregates.values()
+
+            if aggregates != [[None]]:
+                join = []
+                last_alias = "%s_base" % alias
+                last_id = "id"
+                last = Alias(select, last_alias)
+                columns = [
+                    ColumnAS(SQLConstant("%s.%s" % (last_alias, x.expr2)),
+                             x.expr2) for x in columns]
+
+                for i, agg in enumerate(aggregates):
+                    restriction = agg[0]
+                    if restriction is None:
+                        restriction = clause
+                    else:
+                        restriction = AND(clause, restriction)
+                    agg = agg[1:]
+                    agg_alias = "%s_%s" % (alias, i)
+                    agg_id = '%s_id' % agg_alias
+                    if not last.q.alias.endswith('base'):
+                        last = None
+                    new_alias = Alias(Select(
+                        [ColumnAS(cls.sqlmeta.idName, agg_id)] + agg,
+                        groupBy=cls.sqlmeta.idName,
+                        join=metajoin,
+                        clause=restriction),
+                        agg_alias)
+                    agg_join = LEFTJOINOn(last, new_alias,
+                                          "%s.%s = %s.%s" % (
+                                              last_alias, last_id,
+                                              agg_alias, agg_id))
+
+                    join.append(agg_join)
+                    for col in agg:
+                        columns.append(
+                            ColumnAS(SQLConstant(
+                                "%s.%s" % (agg_alias, col.expr2)),
+                                col.expr2))
+
+                    last = new_alias
+                    last_alias = agg_alias
+                    last_id = agg_id
+                select = Select(columns,
+                                join=join)
+
+            cls.sqlmeta.table = Alias(select, alias)
+            cls.q = ViewSQLObjectTable(cls)
+            for n, col in cls.sqlmeta.columns.items():
+                col.dbName = n
+
+
+def isAggregate(expr):
+    if isinstance(expr, SQLCall):
+        return True
+    if isinstance(expr, SQLOp):
+        return isAggregate(expr.expr1) or isAggregate(expr.expr2)
+    return False

sqlobject/wsgi_middleware.py

@@ -0,0 +1,109 @@
+import sys
+import sqlobject
+from sqlobject.compat import string_type
+
+# The module was imported during documentation building
+if 'sphinx' not in sys.modules:
+    from paste.deploy.converters import asbool
+    from paste.wsgilib import catch_errors
+    from paste.util import import_string
+
+
+def make_middleware(app, global_conf, database=None, use_transaction=False,
+                    hub=None):
+    """
+    WSGI middleware that sets the connection for the request (using
+    the database URI or connection object) and the given hub (or
+    ``sqlobject.sqlhub`` if not given).
+
+    If ``use_transaction`` is true, then the request will be run in a
+    transaction.
+
+    Applications can use the keys (which are all no-argument functions):
+
+    ``sqlobject.get_connection()``:
+      Returns the connection object
+
+    ``sqlobject.abort()``:
+      Aborts the transaction.  Does not raise an error, but at the *end*
+      of the request there will be a rollback.
+
+    ``sqlobject.begin()``:
+      Starts a transaction.  First commits (or rolls back if aborted) if
+      this is run in a transaction.
+
+    ``sqlobject.in_transaction()``:
+      Returns true or false, depending if we are currently in a
+      transaction.
+    """
+    use_transaction = asbool(use_transaction)
+    if database is None:
+        database = global_conf.get('database')
+    if not database:
+        raise ValueError(
+            "You must provide a 'database' configuration value")
+    if isinstance(hub, string_type):
+        hub = import_string.eval_import(hub)
+    if not hub:
+        hub = sqlobject.sqlhub
+    if isinstance(database, string_type):
+        database = sqlobject.connectionForURI(database)
+    return SQLObjectMiddleware(app, database, use_transaction, hub)
+
+
+class SQLObjectMiddleware(object):
+
+    def __init__(self, app, conn, use_transaction, hub):
+        self.app = app
+        self.conn = conn
+        self.use_transaction = use_transaction
+        self.hub = hub
+
+    def __call__(self, environ, start_response):
+        conn = [self.conn]
+        if self.use_transaction:
+            conn[0] = conn[0].transaction()
+        any_errors = []
+        use_transaction = [self.use_transaction]
+        self.hub.threadConnection = conn[0]
+
+        def abort():
+            assert use_transaction[0], (
+                "You cannot abort, because a transaction is not being used")
+            any_errors.append(None)
+
+        def begin():
+            if use_transaction[0]:
+                if any_errors:
+                    conn[0].rollback()
+                else:
+                    conn[0].commit()
+            any_errors[:] = []
+            use_transaction[0] = True
+            conn[0] = self.conn.transaction()
+            self.hub.threadConnection = conn[0]
+
+        def error(exc_info=None):
+            any_errors.append(None)
+            ok()
+
+        def ok():
+            if use_transaction[0]:
+                if any_errors:
+                    conn[0].rollback()
+                else:
+                    conn[0].commit(close=True)
+            self.hub.threadConnection = None
+
+        def in_transaction():
+            return use_transaction[0]
+
+        def get_connection():
+            return conn[0]
+
+        environ['sqlobject.get_connection'] = get_connection
+        environ['sqlobject.abort'] = abort
+        environ['sqlobject.begin'] = begin
+        environ['sqlobject.in_transaction'] = in_transaction
+        return catch_errors(self.app, environ, start_response,
+                            error_callback=error, ok_callback=ok)

sqlobject-3.13.1.data/scripts/sqlobject-admin

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+import os
+
+try:
+    import pkg_resources
+    pkg_resources.require('SQLObject>0.6.1')
+except (ImportError, pkg_resources.DistributionNotFound):
+    # Oh well, we tried...
+    pass
+
+try:
+    import sqlobject.manager
+except ImportError:
+    try:
+        here = __file__
+    except NameError:
+        here = sys.argv[0]
+    updir = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.abspath(here))),
+        'sqlobject')
+    if os.path.exists(updir):
+        sys.path.insert(0, os.path.dirname(updir))
+    else:
+        print('I cannot find the sqlobject module')
+        print('If SQLObject is installed, you may need to set $PYTHONPATH')
+        sys.exit(3)
+    # Now we have to get rid of possibly stale modules from that import
+    # up there
+    for name, value in sys.modules.items():
+        if name.startswith('sqlobject'):
+            del sys.modules[name]
+
+from sqlobject.manager import command
+command.the_runner.run(sys.argv)

sqlobject-3.13.1.data/scripts/sqlobject-convertOldURI

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+from __future__ import print_function
+
+import sys
+
+try:
+    uri = sys.argv[1]
+except IndexError:
+    sys.exit("Usage: %s old-style-URI" % sys.argv[0])
+
+try:
+    import pkg_resources
+    pkg_resources.require('SQLObject>=1.0.0')
+except (ImportError, pkg_resources.DistributionNotFound):
+    pass
+
+from sqlobject import connectionForURI
+conn = connectionForURI(uri, oldUri=True)
+print(conn.uri())