sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/__init__.py

@@ -0,0 +1,15 @@
+"""SQLObject"""
+
+# Do import for namespace
+# noqa is a directive for flake8 to ignore seemingly unused imports
+
+from .__version__ import version, version_info  # noqa
+
+from .col import *  # noqa
+from .index import *  # noqa
+from .joins import *  # noqa
+from .main import *  # noqa
+from .sqlbuilder import AND, OR, NOT, IN, LIKE, RLIKE, DESC, CONTAINSSTRING, const, func  # noqa
+from .styles import *  # noqa
+from .dbconnection import connectionForURI  # noqa
+from . import dberrors  # noqa

sqlobject/__version__.py

@@ -0,0 +1,8 @@
+
+version = '3.13.1'
+major = 3
+minor = 13
+micro = 1
+release_level = 'final'
+serial = 0
+version_info = (major, minor, micro, release_level, serial)

sqlobject/boundattributes.py

@@ -0,0 +1,124 @@
+"""
+Bound attributes are attributes that are bound to a specific class and
+a specific name.  In SQLObject a typical example is a column object,
+which knows its name and class.
+
+A bound attribute should define a method ``__addtoclass__(added_class,
+name)`` (attributes without this method will simply be treated as
+normal).  The return value is ignored; if the attribute wishes to
+change the value in the class, it must call ``setattr(added_class,
+name, new_value)``.
+
+BoundAttribute is a class that facilitates lazy attribute creation.
+"""
+from __future__ import absolute_import
+
+from . import declarative
+from . import events
+
+__all__ = ['BoundAttribute', 'BoundFactory']
+
+
+class BoundAttribute(declarative.Declarative):
+
+    """
+    This is a declarative class that passes all the values given to it
+    to another object.  So you can pass it arguments (via
+    __init__/__call__) or give it the equivalent of keyword arguments
+    through subclassing.  Then a bound object will be added in its
+    place.
+
+    To hook this other object in, override ``make_object(added_class,
+    name, **attrs)`` and maybe ``set_object(added_class, name,
+    **attrs)`` (the default implementation of ``set_object``
+    just resets the attribute to whatever ``make_object`` returned).
+
+    Also see ``BoundFactory``.
+    """
+
+    _private_variables = (
+        '_private_variables',
+        '_all_attributes',
+        '__classinit__',
+        '__addtoclass__',
+        '_add_attrs',
+        'set_object',
+        'make_object',
+        'clone_in_subclass',
+    )
+
+    _all_attrs = ()
+    clone_for_subclass = True
+
+    def __classinit__(cls, new_attrs):
+        declarative.Declarative.__classinit__(cls, new_attrs)
+        cls._all_attrs = cls._add_attrs(cls, new_attrs)
+
+    def __instanceinit__(self, new_attrs):
+        declarative.Declarative.__instanceinit__(self, new_attrs)
+        self.__dict__['_all_attrs'] = self._add_attrs(self, new_attrs)
+
+    @staticmethod
+    def _add_attrs(this_object, new_attrs):
+        private = this_object._private_variables
+        all_attrs = list(this_object._all_attrs)
+        for key in new_attrs.keys():
+            if key.startswith('_') or key in private:
+                continue
+            if key not in all_attrs:
+                all_attrs.append(key)
+        return tuple(all_attrs)
+
+    @declarative.classinstancemethod
+    def __addtoclass__(self, cls, added_class, attr_name):
+        me = self or cls
+        attrs = {}
+        for name in me._all_attrs:
+            attrs[name] = getattr(me, name)
+        attrs['added_class'] = added_class
+        attrs['attr_name'] = attr_name
+        obj = me.make_object(**attrs)
+
+        if self.clone_for_subclass:
+            def on_rebind(new_class_name, bases, new_attrs,
+                          post_funcs, early_funcs):
+                def rebind(new_class):
+                    me.set_object(
+                        new_class, attr_name,
+                        me.make_object(**attrs))
+                post_funcs.append(rebind)
+            events.listen(receiver=on_rebind, soClass=added_class,
+                          signal=events.ClassCreateSignal, weak=False)
+
+        me.set_object(added_class, attr_name, obj)
+
+    @classmethod
+    def set_object(cls, added_class, attr_name, obj):
+        setattr(added_class, attr_name, obj)
+
+    @classmethod
+    def make_object(cls, added_class, attr_name, *args, **attrs):
+        raise NotImplementedError
+
+    def __setattr__(self, name, value):
+        self.__dict__['_all_attrs'] = self._add_attrs(self, {name: value})
+        self.__dict__[name] = value
+
+
+class BoundFactory(BoundAttribute):
+
+    """
+    This will bind the attribute to whatever is given by
+    ``factory_class``.  This factory should be a callable with the
+    signature ``factory_class(added_class, attr_name, *args, **kw)``.
+
+    The factory will be reinvoked (and the attribute rebound) for
+    every subclassing.
+    """
+
+    factory_class = None
+    _private_variables = (
+        BoundAttribute._private_variables + ('factory_class',))
+
+    def make_object(cls, added_class, attr_name, *args, **kw):
+        return cls.factory_class(added_class, attr_name, *args, **kw)

sqlobject/cache.py

@@ -0,0 +1,376 @@
+"""
+This implements the instance caching in SQLObject.  Caching is
+relatively aggressive.  All objects are retained so long as they are
+in memory, by keeping weak references to objects.  We also keep other
+objects in a cache that doesn't allow them to be garbage collected
+(unless caching is turned off).
+"""
+
+import threading
+from weakref import ref
+
+
+class CacheFactory(object):
+
+    """
+    CacheFactory caches object creation.  Each object should be
+    referenced by a single hashable ID (note tuples of hashable
+    values are also hashable).
+
+    """
+
+    def __init__(self, cullFrequency=100, cullFraction=2,
+                 cache=True):
+        """
+        Every cullFrequency times that an item is retrieved from
+        this cache, the cull method is called.
+
+        The cull method then expires an arbitrary fraction of
+        the cached objects.  The idea is at no time will the cache
+        be entirely emptied, placing a potentially high load at that
+        moment, but everything object will have its time to go
+        eventually.  The fraction is given as an integer, and one
+        in that many objects are expired (i.e., the default is 1/2
+        of objects are expired).
+
+        By setting cache to False, items won't be cached.
+
+        However, in all cases a weak reference is kept to created
+        objects, and if the object hasn't been garbage collected
+        it will be returned.
+        """
+
+        self.cullFrequency = cullFrequency
+        self.cullCount = 0
+        self.cullOffset = 0
+        self.cullFraction = cullFraction
+        self.doCache = cache
+
+        if self.doCache:
+            self.cache = {}
+        self.expiredCache = {}
+        self.lock = threading.Lock()
+
+    def tryGet(self, id):
+        """
+        This returns None, or the object in cache.
+        """
+        value = self.expiredCache.get(id)
+        if value:
+            # it's actually a weakref:
+            return value()
+        if not self.doCache:
+            return None
+        return self.cache.get(id)
+
+    def get(self, id):
+        """
+        This method can cause deadlocks!  tryGet is safer
+
+        This returns the object found in cache, or None.  If None,
+        then the cache will remain locked!  This is so that the
+        calling function can create the object in a threadsafe manner
+        before releasing the lock.  You should use this like (note
+        that ``cache`` is actually a CacheSet object in this
+        example)::
+
+          obj = cache.get(some_id, my_class)
+          if obj is None:
+              try:
+                  obj = create_object(some_id)
+                  cache.put(some_id, my_class, obj)
+              finally:
+                  cache.finishPut(cls)
+
+        This method checks both the main cache (which retains
+        references) and the 'expired' cache, which retains only weak
+        references.
+        """
+
+        if self.doCache:
+            if self.cullCount > self.cullFrequency:
+                # Two threads could hit the cull in a row, but
+                # that's not so bad.  At least by setting cullCount
+                # back to zero right away we avoid this.  The cull
+                # method has a lock, so it's threadsafe.
+                self.cullCount = 0
+                self.cull()
+            else:
+                self.cullCount = self.cullCount + 1
+
+            try:
+                return self.cache[id]
+            except KeyError:
+                pass
+            self.lock.acquire()
+            try:
+                val = self.cache[id]
+            except KeyError:
+                pass
+            else:
+                self.lock.release()
+                return val
+            try:
+                val = self.expiredCache[id]()
+            except KeyError:
+                return None
+            else:
+                del self.expiredCache[id]
+                if val is None:
+                    return None
+            self.cache[id] = val
+            self.lock.release()
+            return val
+
+        else:
+            try:
+                val = self.expiredCache[id]()
+                if val is not None:
+                    return val
+            except KeyError:
+                pass
+            self.lock.acquire()
+            try:
+                val = self.expiredCache[id]()
+            except KeyError:
+                return None
+            else:
+                if val is None:
+                    del self.expiredCache[id]
+                    return None
+            self.lock.release()
+            return val
+
+    def put(self, id, obj):
+        """
+        Puts an object into the cache.  Should only be called after
+        .get(), so that duplicate objects don't end up in the cache.
+        """
+        if self.doCache:
+            self.cache[id] = obj
+        else:
+            self.expiredCache[id] = ref(obj)
+
+    def finishPut(self):
+        """
+        Releases the lock that is retained when .get() is called and
+        returns None.
+        """
+        self.lock.release()
+
+    def created(self, id, obj):
+        """
+        Inserts and object into the cache.  Should be used when no one
+        else knows about the object yet, so there cannot be any object
+        already in the cache.  After a database INSERT is an example
+        of this situation.
+        """
+        if self.doCache:
+            if self.cullCount > self.cullFrequency:
+                # Two threads could hit the cull in a row, but
+                # that's not so bad.  At least by setting cullCount
+                # back to zero right away we avoid this.  The cull
+                # method has a lock, so it's threadsafe.
+                self.cullCount = 0
+                self.cull()
+            else:
+                self.cullCount = self.cullCount + 1
+            self.cache[id] = obj
+        else:
+            self.expiredCache[id] = ref(obj)
+
+    def cull(self):
+        """Runs through the cache and expires objects
+
+        E.g., if ``cullFraction`` is 3, then every third object is moved to
+        the 'expired' (aka weakref) cache.
+
+        """
+        self.lock.acquire()
+        try:
+            # remove dead references from the expired cache
+            keys = list(self.expiredCache.keys())
+            for key in keys:
+                if self.expiredCache[key]() is None:
+                    self.expiredCache.pop(key, None)
+
+            keys = list(self.cache.keys())
+            for i in range(self.cullOffset, len(keys), self.cullFraction):
+                id = keys[i]
+                # create a weakref, then remove from the cache
+                obj = ref(self.cache[id])
+                del self.cache[id]
+
+                # the object may have been gc'd when removed from the cache
+                # above, no need to place in expiredCache
+                if obj() is not None:
+                    self.expiredCache[id] = obj
+            # This offset tries to balance out which objects we
+            # expire, so no object will just hang out in the cache
+            # forever.
+            self.cullOffset = (self.cullOffset + 1) % self.cullFraction
+        finally:
+            self.lock.release()
+
+    def clear(self):
+        """
+        Removes everything from the cache.  Warning!  This can cause
+        duplicate objects in memory.
+        """
+        if self.doCache:
+            self.cache.clear()
+        self.expiredCache.clear()
+
+    def expire(self, id):
+        """
+        Expires a single object.  Typically called after a delete.
+        Doesn't even keep a weakref.  (@@: bad name?)
+        """
+        if not self.doCache:
+            return
+        self.lock.acquire()
+        try:
+            if id in self.cache:
+                del self.cache[id]
+            if id in self.expiredCache:
+                del self.expiredCache[id]
+        finally:
+            self.lock.release()
+
+    def expireAll(self):
+        """
+        Expires all objects, moving them all into the expired/weakref
+        cache.
+        """
+        if not self.doCache:
+            return
+        self.lock.acquire()
+        try:
+            for key, value in self.cache.items():
+                self.expiredCache[key] = ref(value)
+            self.cache = {}
+        finally:
+            self.lock.release()
+
+    def allIDs(self):
+        """
+        Returns the IDs of all objects in the cache.
+        """
+        if self.doCache:
+            all = list(self.cache.keys())
+        else:
+            all = []
+        for id, value in self.expiredCache.items():
+            if value():
+                all.append(id)
+        return all
+
+    def getAll(self):
+        """
+        Return all the objects in the cache.
+        """
+        if self.doCache:
+            all = list(self.cache.values())
+        else:
+            all = []
+        for value in self.expiredCache.values():
+            if value():
+                all.append(value())
+        return all
+
+
+class CacheSet(object):
+
+    """
+    A CacheSet is used to collect and maintain a series of caches.  In
+    SQLObject, there is one CacheSet per connection, and one Cache
+    in the CacheSet for each class, since IDs are not unique across
+    classes.  It contains methods similar to Cache, but that take
+    a ``cls`` argument.
+    """
+
+    def __init__(self, *args, **kw):
+        self.caches = {}
+        self.args = args
+        self.kw = kw
+
+    def get(self, id, cls):
+        try:
+            return self.caches[cls.__name__].get(id)
+        except KeyError:
+            self.caches[cls.__name__] = CacheFactory(*self.args, **self.kw)
+            return self.caches[cls.__name__].get(id)
+
+    def put(self, id, cls, obj):
+        self.caches[cls.__name__].put(id, obj)
+
+    def finishPut(self, cls):
+        self.caches[cls.__name__].finishPut()
+
+    def created(self, id, cls, obj):
+        try:
+            self.caches[cls.__name__].created(id, obj)
+        except KeyError:
+            self.caches[cls.__name__] = CacheFactory(*self.args, **self.kw)
+            self.caches[cls.__name__].created(id, obj)
+
+    def expire(self, id, cls):
+        try:
+            self.caches[cls.__name__].expire(id)
+        except KeyError:
+            pass
+
+    def clear(self, cls=None):
+        if cls is None:
+            for cache in self.caches.values():
+                cache.clear()
+        elif cls.__name__ in self.caches:
+            self.caches[cls.__name__].clear()
+
+    def tryGet(self, id, cls):
+        return self.tryGetByName(id, cls.__name__)
+
+    def tryGetByName(self, id, clsname):
+        try:
+            return self.caches[clsname].tryGet(id)
+        except KeyError:
+            return None
+
+    def allIDs(self, cls):
+        try:
+            self.caches[cls.__name__].allIDs()
+        except KeyError:
+            return []
+
+    def allSubCaches(self):
+        return self.caches.values()
+
+    def allSubCachesByClassNames(self):
+        return self.caches
+
+    def weakrefAll(self, cls=None):
+        """
+        Move all objects in the cls (or if not given, then in all
+        classes) to the weakref dictionary, where they can be
+        collected.
+        """
+        if cls is None:
+            for cache in self.caches.values():
+                cache.expireAll()
+        elif cls.__name__ in self.caches:
+            self.caches[cls.__name__].expireAll()
+
+    def getAll(self, cls=None):
+        """
+        Returns all instances in the cache for the given class or all
+        classes.
+        """
+        if cls is None:
+            results = []
+            for cache in self.caches.values():
+                results.extend(cache.getAll())
+            return results
+        elif cls.__name__ in self.caches:
+            return self.caches[cls.__name__].getAll()
+        else:
+            return []

sqlobject/classregistry.py

@@ -0,0 +1,138 @@
+"""
+classresolver.py
+  2 February 2004, Ian Bicking <ianb@colorstudy.com>
+
+Resolves strings to classes, and runs callbacks when referenced
+classes are created.
+
+Classes are referred to only by name, not by module.  So that
+identically-named classes can coexist, classes are put into individual
+registries, which are keyed on strings (names).  These registries are
+created on demand.
+
+Use like::
+
+    >>> import classregistry
+    >>> registry = classregistry.registry('MyModules')
+    >>> def afterMyClassExists(cls):
+    ...    print('Class finally exists: %s' % cls)
+    >>> registry.addClassCallback('MyClass', afterMyClassExists)
+    >>> class MyClass:
+    ...    pass
+    >>> registry.addClass(MyClass)
+    Class finally exists: MyClass
+
+"""
+
+
+class ClassRegistry(object):
+    """
+    We'll be dealing with classes that reference each other, so
+    class C1 may reference C2 (in a join), while C2 references
+    C1 right back.  Since classes are created in an order, there
+    will be a point when C1 exists but C2 doesn't.  So we deal
+    with classes by name, and after each class is created we
+    try to fix up any references by replacing the names with
+    actual classes.
+
+    Here we keep a dictionaries of class names to classes -- note
+    that the classes might be spread among different modules, so
+    since we pile them together names need to be globally unique,
+    to just module unique.
+    Like needSet below, the container dictionary is keyed by the
+    class registry.
+    """
+
+    def __init__(self, name):
+        self.name = name
+        self.classes = {}
+        self.callbacks = {}
+        self.genericCallbacks = []
+
+    def addClassCallback(self, className, callback, *args, **kw):
+        """
+        Whenever a name is substituted for the class, you can register
+        a callback that will be called when the needed class is
+        created.  If it's already been created, the callback will be
+        called immediately.
+        """
+        if className in self.classes:
+            callback(self.classes[className], *args, **kw)
+        else:
+            self.callbacks.setdefault(className, []).append(
+                (callback, args, kw))
+
+    def addCallback(self, callback, *args, **kw):
+        """
+        This callback is called for all classes, not just specific
+        ones (like addClassCallback).
+        """
+        self.genericCallbacks.append((callback, args, kw))
+        for cls in self.classes.values():
+            callback(cls, *args, **kw)
+
+    def addClass(self, cls):
+        """
+        Everytime a class is created, we add it to the registry, so
+        that other classes can find it by name.  We also call any
+        callbacks that are waiting for the class.
+        """
+        if cls.__name__ in self.classes:
+            import sys
+            other = self.classes[cls.__name__]
+            raise ValueError(
+                "class %s is already in the registry (other class is "
+                "%r, from the module %s in %s; attempted new class is "
+                "%r, from the module %s in %s)"
+                % (cls.__name__,
+                   other, other.__module__,
+                   getattr(sys.modules.get(other.__module__),
+                           '__file__', '(unknown)'),
+                   cls, cls.__module__,
+                   getattr(sys.modules.get(cls.__module__),
+                           '__file__', '(unknown)')))
+        self.classes[cls.__name__] = cls
+        if cls.__name__ in self.callbacks:
+            for callback, args, kw in self.callbacks[cls.__name__]:
+                callback(cls, *args, **kw)
+            del self.callbacks[cls.__name__]
+        for callback, args, kw in self.genericCallbacks:
+            callback(cls, *args, **kw)
+
+    def getClass(self, className):
+        try:
+            return self.classes[className]
+        except KeyError:
+            all = sorted(self.classes.keys())
+            raise KeyError(
+                "No class %s found in the registry %s (these classes "
+                "exist: %s)"
+                % (className, self.name or '[default]', ', '.join(all)))
+
+    def allClasses(self):
+        return self.classes.values()
+
+
+class _MasterRegistry(object):
+    """
+    This singleton holds all the class registries.  There can be
+    multiple registries to hold different unrelated sets of classes
+    that reside in the same process.  These registries are named with
+    strings, and are created on demand.  The MasterRegistry module
+    global holds the singleton.
+    """
+
+    def __init__(self):
+        self.registries = {}
+
+    def registry(self, item):
+        if item not in self.registries:
+            self.registries[item] = ClassRegistry(item)
+        return self.registries[item]
+
+MasterRegistry = _MasterRegistry()
+registry = MasterRegistry.registry
+
+
+def findClass(name, class_registry=None):
+    return registry(class_registry).getClass(name)