sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/dberrors.py

@@ -0,0 +1,54 @@
+"""dberrors: database exception classes for SQLObject.
+
+   These classes are dictated by the DB API v2.0, see:
+   https://wiki.python.org/moin/DatabaseProgramming
+"""
+
+from sqlobject.compat import PY2
+
+if not PY2:
+    StandardError = Exception
+
+
+class Error(StandardError):
+    pass
+
+
+class Warning(StandardError):
+    pass
+
+
+class InterfaceError(Error):
+    pass
+
+
+class DatabaseError(Error):
+    pass
+
+
+class InternalError(DatabaseError):
+    pass
+
+
+class OperationalError(DatabaseError):
+    pass
+
+
+class ProgrammingError(DatabaseError):
+    pass
+
+
+class IntegrityError(DatabaseError):
+    pass
+
+
+class DataError(DatabaseError):
+    pass
+
+
+class NotSupportedError(DatabaseError):
+    pass
+
+
+class DuplicateEntryError(IntegrityError):
+    pass

sqlobject/declarative.py

@@ -0,0 +1,211 @@
+"""
+Declarative objects.
+
+Declarative objects have a simple protocol: you can use classes in
+lieu of instances and they are equivalent, and any keyword arguments
+you give to the constructor will override those instance variables.
+(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.
+
+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.
+
+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.
+"""
+
+import copy
+from . import events
+from sqlobject.compat import with_metaclass
+
+import itertools
+counter = itertools.count()
+
+__all__ = ('classinstancemethod', 'DeclarativeMeta', 'Declarative')
+
+
+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 'self' not in kw and 'cls' not in kw, (
+            "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.__name__))
+        else:
+            return ('<bound method %s.%s of %r>'
+                    % (self.type.__name__, self.func.__name__, self.obj))
+
+
+class DeclarativeMeta(type):
+
+    def __new__(meta, class_name, bases, new_attrs):
+        post_funcs = []
+        early_funcs = []
+        events.send(events.ClassCreateSignal,
+                    bases[0], class_name, bases, new_attrs,
+                    post_funcs, early_funcs)
+        cls = type.__new__(meta, class_name, bases, new_attrs)
+        for func in early_funcs:
+            func(cls)
+        if '__classinit__' in new_attrs:
+            if hasattr(cls.__classinit__, '__func__'):
+                cls.__classinit__ = staticmethod(cls.__classinit__.__func__)
+            else:
+                cls.__classinit__ = staticmethod(cls.__classinit__)
+        cls.__classinit__(cls, new_attrs)
+        for func in post_funcs:
+            func(cls)
+        return cls
+
+
+class Declarative(with_metaclass(DeclarativeMeta, object)):
+
+    __unpackargs__ = ()
+
+    __mutableattributes__ = ()
+
+    __restrict_attributes__ = None
+
+    def __classinit__(cls, new_attrs):
+        cls.declarative_count = next(counter)
+        for name in cls.__mutableattributes__:
+            if name not in new_attrs:
+                setattr(cls, copy.copy(getattr(cls, name)))
+
+    def __instanceinit__(self, new_attrs):
+        if self.__restrict_attributes__ is not None:
+            for name in new_attrs:
+                if name not in self.__restrict_attributes__:
+                    raise TypeError(
+                        '%s() got an unexpected keyword argument %r'
+                        % (self.__class__.__name__, name))
+        for name, value in new_attrs.items():
+            setattr(self, name, value)
+        if 'declarative_count' not in new_attrs:
+            self.declarative_count = next(counter)
+
+    def __init__(self, *args, **kw):
+        if self.__unpackargs__ and self.__unpackargs__[0] == '*':
+            assert len(self.__unpackargs__) == 2, \
+                "When using __unpackargs__ = ('*', varname), " \
+                "you must only provide a single variable name " \
+                "(you gave %r)" % self.__unpackargs__
+            name = self.__unpackargs__[1]
+            if name in kw:
+                raise TypeError(
+                    "keyword parameter '%s' was given by position and name"
+                    % name)
+            kw[name] = args
+        else:
+            if len(args) > len(self.__unpackargs__):
+                raise TypeError(
+                    '%s() takes at most %i arguments (%i given)'
+                    % (self.__class__.__name__,
+                       len(self.__unpackargs__),
+                       len(args)))
+            for name, arg in zip(self.__unpackargs__, args):
+                if name in kw:
+                    raise TypeError(
+                        "keyword parameter '%s' was given by position and name"
+                        % name)
+                kw[name] = arg
+        if '__alsocopy' in kw:
+            for name, value in kw['__alsocopy'].items():
+                if name not in kw:
+                    if name in self.__mutableattributes__:
+                        value = copy.copy(value)
+                    kw[name] = value
+            del kw['__alsocopy']
+        self.__instanceinit__(kw)
+
+    def __call__(self, *args, **kw):
+        kw['__alsocopy'] = self.__dict__
+        return self.__class__(*args, **kw)
+
+    @classinstancemethod
+    def singleton(self, cls):
+        if self:
+            return self
+        name = '_%s__singleton' % cls.__name__
+        if not hasattr(cls, name):
+            setattr(cls, name, cls(declarative_count=cls.declarative_count))
+        return getattr(cls, name)
+
+    @classinstancemethod
+    def __repr__(self, cls):
+        if self:
+            name = '%s object' % self.__class__.__name__
+            v = self.__dict__.copy()
+        else:
+            name = '%s class' % cls.__name__
+            v = cls.__dict__.copy()
+        if 'declarative_count' in v:
+            name = '%s %i' % (name, v['declarative_count'])
+            del v['declarative_count']
+        # @@: simplifying repr:
+        # v = {}
+        names = v.keys()
+        args = []
+        for n in self._repr_vars(names):
+            args.append('%s=%r' % (n, v[n]))
+        if not args:
+            return '<%s>' % name
+        else:
+            return '<%s %s>' % (name, ' '.join(args))
+
+    @staticmethod
+    def _repr_vars(dictNames):
+        names = [n for n in dictNames
+                 if not n.startswith('_')
+                 and n != 'declarative_count']
+        names.sort()
+        return names
+
+
+def setup_attributes(cls, new_attrs):
+    for name, value in new_attrs.items():
+        if hasattr(value, '__addtoclass__'):
+            value.__addtoclass__(cls, name)

sqlobject/events.py

@@ -0,0 +1,365 @@
+from __future__ import print_function
+import sys
+import types
+from pydispatch import dispatcher
+from weakref import ref
+from .compat import class_types
+
+
+subclassClones = {}
+
+
+def listen(receiver, soClass, signal, alsoSubclasses=True, weak=True):
+    """
+    Listen for the given ``signal`` on the SQLObject subclass
+    ``soClass``, calling ``receiver()`` when ``send(soClass, signal,
+    ...)`` is called.
+
+    If ``alsoSubclasses`` is true, receiver will also be called when
+    an event is fired on any subclass.
+    """
+    dispatcher.connect(receiver, signal=signal, sender=soClass, weak=weak)
+    weakReceiver = ref(receiver)
+    subclassClones.setdefault(soClass, []).append((weakReceiver, signal))
+
+# We export this function:
+send = dispatcher.send
+
+
+class Signal(object):
+    """
+    Base event for all SQLObject events.
+
+    In general the sender for these methods is the class, not the
+    instance.
+    """
+
+
+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__``).
+    """
+
+
+def _makeSubclassConnections(new_class_name, bases, new_attrs,
+                             post_funcs, early_funcs):
+    early_funcs.insert(0, _makeSubclassConnectionsPost)
+
+
+def _makeSubclassConnectionsPost(new_class):
+    for cls in new_class.__bases__:
+        for weakReceiver, signal in subclassClones.get(cls, []):
+            receiver = weakReceiver()
+            if not receiver:
+                continue
+            listen(receiver, new_class, signal)
+
+dispatcher.connect(_makeSubclassConnections, signal=ClassCreateSignal)
+
+
+# @@: 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 ``(instance, 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.
+    """
+
+
+class RowCreatedSignal(Signal):
+    """
+    Called after an instance is created, with the class as the
+    sender.  Called with the arguments ``(instance, 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, post_funcs)``.
+
+    ``post_funcs`` is a list of callbacks, intended to have
+    functions appended to it, and are called with arguments ``(instance)``.
+    If any of the post_funcs raises an exception, the deletion is only
+    affected if this will prevent a commit.
+
+    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 RowDestroyedSignal(Signal):
+    """
+    Called after an instance is deleted.  Sender is the instance's
+    class.  Arguments are ``(instance)``.
+
+    This is called before the post_funcs of RowDestroySignal
+
+    Note: this is not called when an instance is destroyed through
+    garbage collection.
+    """
+
+
+class RowUpdateSignal(Signal):
+    """
+    Called when an instance is updated through a call to ``.set()``
+    (or a column attribute assignment).  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 RowUpdatedSignal(Signal):
+    """
+    Called when an instance is updated through a call to ``.set()``
+    (or a column attribute assignment).  The arguments are
+    ``(instance, post_funcs)``. ``post_funcs`` is a list of callbacks,
+    intended to have functions appended to it, and are called with the
+    arguments ``(new_instance)``. This is run *after* the instance is
+    updated; Works better with lazyUpdate = True.
+    """
+
+
+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.
+    """
+
+
+class CommitSignal(Signal):
+    """
+    Called on transaction commit
+    """
+
+
+class RollbackSignal(Signal):
+    """
+    Called on transaction rollback
+    """
+
+
+############################################################
+# Event Debugging
+############################################################
+
+
+def summarize_events_by_sender(sender=None, output=None, indent=0):
+    """
+    Prints out a summary of the senders and listeners in the system,
+    for debugging purposes.
+    """
+    if output is None:
+        output = sys.stdout
+    leader = ' ' * indent
+    if sender is None:
+        send_list = [
+            (deref(dispatcher.senders.get(sid)), listeners)
+            for sid, listeners in dispatcher.connections.items()
+            if deref(dispatcher.senders.get(sid))]
+        for sender, listeners in sorted_items(send_list):
+            real_sender = deref(sender)
+            if not real_sender:
+                continue
+            header = 'Sender: %r' % real_sender
+            print(leader + header, file=output)
+            print(leader + ('=' * len(header)), file=output)
+            summarize_events_by_sender(real_sender, output=output,
+                                       indent=indent + 2)
+    else:
+        for signal, receivers in \
+                sorted_items(dispatcher.connections.get(id(sender), [])):
+            receivers = [deref(r) for r in receivers if deref(r)]
+            header = 'Signal: %s (%i receivers)' % (sort_name(signal),
+                                                    len(receivers))
+            print(leader + header, file=output)
+            print(leader + ('-' * len(header)), file=output)
+            for receiver in sorted(receivers, key=sort_name):
+                print(leader + '  ' + nice_repr(receiver), file=output)
+
+
+def deref(value):
+    if isinstance(value, dispatcher.WEAKREF_TYPES):
+        return value()
+    else:
+        return value
+
+
+def sorted_items(a_dict):
+    if isinstance(a_dict, dict):
+        a_dict = a_dict.items()
+    return sorted(a_dict, key=lambda t: sort_name(t[0]))
+
+
+def sort_name(value):
+    if isinstance(value, type):
+        return value.__name__
+    elif isinstance(value, types.FunctionType):
+        return value.__name__
+    else:
+        return str(value)
+
+_real_dispatcher_send = dispatcher.send
+_real_dispatcher_sendExact = dispatcher.sendExact
+_real_dispatcher_connect = dispatcher.connect
+_real_dispatcher_disconnect = dispatcher.disconnect
+_debug_enabled = False
+
+
+def debug_events():
+    global _debug_enabled, send
+    if _debug_enabled:
+        return
+    _debug_enabled = True
+    dispatcher.send = send = _debug_send
+    dispatcher.sendExact = _debug_sendExact
+    dispatcher.disconnect = _debug_disconnect
+    dispatcher.connect = _debug_connect
+
+
+def _debug_send(signal=dispatcher.Any, sender=dispatcher.Anonymous,
+                *arguments, **named):
+    print("send %s from %s: %s" % (
+          nice_repr(signal), nice_repr(sender),
+          fmt_args(*arguments, **named)))
+    return _real_dispatcher_send(signal, sender, *arguments, **named)
+
+
+def _debug_sendExact(signal=dispatcher.Any, sender=dispatcher.Anonymous,
+                     *arguments, **named):
+    print("sendExact %s from %s: %s" % (
+          nice_repr(signal), nice_repr(sender), fmt_args(*arguments, **name)))
+    return _real_dispatcher_sendExact(signal, sender, *arguments, **named)
+
+
+def _debug_connect(receiver, signal=dispatcher.Any, sender=dispatcher.Any,
+                   weak=True):
+    print("connect %s to %s signal %s" % (
+          nice_repr(receiver), nice_repr(signal), nice_repr(sender)))
+    return _real_dispatcher_connect(receiver, signal, sender, weak)
+
+
+def _debug_disconnect(receiver, signal=dispatcher.Any, sender=dispatcher.Any,
+                      weak=True):
+    print("disconnecting %s from %s signal %s" % (
+          nice_repr(receiver), nice_repr(signal), nice_repr(sender)))
+    return _real_dispatcher_disconnect(receiver, signal, sender, weak)
+
+
+def fmt_args(*arguments, **name):
+    args = [repr(a) for a in arguments]
+    args.extend([
+        '%s=%r' % (n, v) for n, v in sorted(name.items())])
+    return ', '.join(args)
+
+
+def nice_repr(v):
+    """
+    Like repr(), but nicer for debugging here.
+    """
+    if isinstance(v, class_types):
+        return v.__module__ + '.' + v.__name__
+    elif isinstance(v, types.FunctionType):
+        if '__name__' in v.__globals__:
+            if getattr(sys.modules[v.__globals__['__name__']],
+                       v.__name__, None) is v:
+                return '%s.%s' % (v.__globals__['__name__'], v.__name__)
+        return repr(v)
+    elif isinstance(v, types.MethodType):
+        return '%s.%s of %s' % (
+            nice_repr(v.__self__.__class__), v.__func__.__name__,
+            nice_repr(v.__self__))
+    else:
+        return repr(v)
+
+
+__all__ = ['listen', 'send']
+# Use copy() to avoid 'dictionary changed' issues on python 3
+for name, value in globals().copy().items():
+    if isinstance(value, type) and issubclass(value, Signal):
+        __all__.append(name)

sqlobject/firebird/__init__.py

@@ -0,0 +1,8 @@
+from sqlobject.dbconnection import registerConnection
+
+
+def builder():
+    from . import firebirdconnection
+    return firebirdconnection.FirebirdConnection
+
+registerConnection(['firebird', 'interbase'], builder)