added all server files

3 files changed, 572 insertions, 0 deletions

diff --git a/lib/python2.7/site-packages/django/dispatch/__init__.py b/lib/python2.7/site-packages/django/dispatch/__init__.py
new file mode 100644
index 0000000..9aeb83c
--- /dev/null
+++ b/lib/python2.7/site-packages/django/dispatch/__init__.py
@@ -0,0 +1,9 @@
+"""Multi-consumer multi-producer dispatching mechanism
+
+Originally based on pydispatch (BSD) http://pypi.python.org/pypi/PyDispatcher/2.0.1
+See license.txt for original license.
+
+Heavily modified for Django's purposes.
+"""
+
+from django.dispatch.dispatcher import Signal, receiver
\ No newline at end of file
diff --git a/lib/python2.7/site-packages/django/dispatch/dispatcher.py b/lib/python2.7/site-packages/django/dispatch/dispatcher.py
new file mode 100644
index 0000000..d26433a
--- /dev/null
+++ b/lib/python2.7/site-packages/django/dispatch/dispatcher.py
@@ -0,0 +1,306 @@
+import weakref
+import threading
+
+from django.dispatch import saferef
+from django.utils.six.moves import xrange
+
+
+WEAKREF_TYPES = (weakref.ReferenceType, saferef.BoundMethodWeakref)
+
+
+def _make_id(target):
+    if hasattr(target, '__func__'):
+        return (id(target.__self__), id(target.__func__))
+    return id(target)
+NONE_ID = _make_id(None)
+
+# A marker for caching
+NO_RECEIVERS = object()
+
+
+class Signal(object):
+    """
+    Base class for all signals
+
+    Internal attributes:
+
+        receivers
+            { receriverkey (id) : weakref(receiver) }
+    """
+    def __init__(self, providing_args=None, use_caching=False):
+        """
+        Create a new signal.
+
+        providing_args
+            A list of the arguments this signal can pass along in a send() call.
+        """
+        self.receivers = []
+        if providing_args is None:
+            providing_args = []
+        self.providing_args = set(providing_args)
+        self.lock = threading.Lock()
+        self.use_caching = use_caching
+        # For convenience we create empty caches even if they are not used.
+        # A note about caching: if use_caching is defined, then for each
+        # distinct sender we cache the receivers that sender has in
+        # 'sender_receivers_cache'. The cache is cleaned when .connect() or
+        # .disconnect() is called and populated on send().
+        self.sender_receivers_cache = weakref.WeakKeyDictionary() if use_caching else {}
+
+    def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
+        """
+        Connect receiver to sender for signal.
+
+        Arguments:
+
+            receiver
+                A function or an instance method which is to receive signals.
+                Receivers must be hashable objects.
+
+                If weak is True, then receiver must be weak-referencable (more
+                precisely saferef.safeRef() must be able to create a reference
+                to the receiver).
+
+                Receivers must be able to accept keyword arguments.
+
+                If receivers have a dispatch_uid attribute, the receiver will
+                not be added if another receiver already exists with that
+                dispatch_uid.
+
+            sender
+                The sender to which the receiver should respond. Must either be
+                of type Signal, or None to receive events from any sender.
+
+            weak
+                Whether to use weak references to the receiver. By default, the
+                module will attempt to use weak references to the receiver
+                objects. If this parameter is false, then strong references will
+                be used.
+
+            dispatch_uid
+                An identifier used to uniquely identify a particular instance of
+                a receiver. This will usually be a string, though it may be
+                anything hashable.
+        """
+        from django.conf import settings
+
+        # If DEBUG is on, check that we got a good receiver
+        if settings.configured and settings.DEBUG:
+            import inspect
+            assert callable(receiver), "Signal receivers must be callable."
+
+            # Check for **kwargs
+            # Not all callables are inspectable with getargspec, so we'll
+            # try a couple different ways but in the end fall back on assuming
+            # it is -- we don't want to prevent registration of valid but weird
+            # callables.
+            try:
+                argspec = inspect.getargspec(receiver)
+            except TypeError:
+                try:
+                    argspec = inspect.getargspec(receiver.__call__)
+                except (TypeError, AttributeError):
+                    argspec = None
+            if argspec:
+                assert argspec[2] is not None, \
+                    "Signal receivers must accept keyword arguments (**kwargs)."
+
+        if dispatch_uid:
+            lookup_key = (dispatch_uid, _make_id(sender))
+        else:
+            lookup_key = (_make_id(receiver), _make_id(sender))
+
+        if weak:
+            receiver = saferef.safeRef(receiver, onDelete=self._remove_receiver)
+
+        with self.lock:
+            for r_key, _ in self.receivers:
+                if r_key == lookup_key:
+                    break
+            else:
+                self.receivers.append((lookup_key, receiver))
+            self.sender_receivers_cache.clear()
+
+    def disconnect(self, receiver=None, sender=None, weak=True, dispatch_uid=None):
+        """
+        Disconnect receiver from sender for signal.
+
+        If weak references are used, disconnect need not be called. The receiver
+        will be remove from dispatch automatically.
+
+        Arguments:
+
+            receiver
+                The registered receiver to disconnect. May be none if
+                dispatch_uid is specified.
+
+            sender
+                The registered sender to disconnect
+
+            weak
+                The weakref state to disconnect
+
+            dispatch_uid
+                the unique identifier of the receiver to disconnect
+        """
+        if dispatch_uid:
+            lookup_key = (dispatch_uid, _make_id(sender))
+        else:
+            lookup_key = (_make_id(receiver), _make_id(sender))
+
+        with self.lock:
+            for index in xrange(len(self.receivers)):
+                (r_key, _) = self.receivers[index]
+                if r_key == lookup_key:
+                    del self.receivers[index]
+                    break
+            self.sender_receivers_cache.clear()
+
+    def has_listeners(self, sender=None):
+        return bool(self._live_receivers(sender))
+
+    def send(self, sender, **named):
+        """
+        Send signal from sender to all connected receivers.
+
+        If any receiver raises an error, the error propagates back through send,
+        terminating the dispatch loop, so it is quite possible to not have all
+        receivers called if a raises an error.
+
+        Arguments:
+
+            sender
+                The sender of the signal Either a specific object or None.
+
+            named
+                Named arguments which will be passed to receivers.
+
+        Returns a list of tuple pairs [(receiver, response), ... ].
+        """
+        responses = []
+        if not self.receivers or self.sender_receivers_cache.get(sender) is NO_RECEIVERS:
+            return responses
+
+        for receiver in self._live_receivers(sender):
+            response = receiver(signal=self, sender=sender, **named)
+            responses.append((receiver, response))
+        return responses
+
+    def send_robust(self, sender, **named):
+        """
+        Send signal from sender to all connected receivers catching errors.
+
+        Arguments:
+
+            sender
+                The sender of the signal. Can be any python object (normally one
+                registered with a connect if you actually want something to
+                occur).
+
+            named
+                Named arguments which will be passed to receivers. These
+                arguments must be a subset of the argument names defined in
+                providing_args.
+
+        Return a list of tuple pairs [(receiver, response), ... ]. May raise
+        DispatcherKeyError.
+
+        If any receiver raises an error (specifically any subclass of
+        Exception), the error instance is returned as the result for that
+        receiver.
+        """
+        responses = []
+        if not self.receivers or self.sender_receivers_cache.get(sender) is NO_RECEIVERS:
+            return responses
+
+        # Call each receiver with whatever arguments it can accept.
+        # Return a list of tuple pairs [(receiver, response), ... ].
+        for receiver in self._live_receivers(sender):
+            try:
+                response = receiver(signal=self, sender=sender, **named)
+            except Exception as err:
+                responses.append((receiver, err))
+            else:
+                responses.append((receiver, response))
+        return responses
+
+    def _live_receivers(self, sender):
+        """
+        Filter sequence of receivers to get resolved, live receivers.
+
+        This checks for weak references and resolves them, then returning only
+        live receivers.
+        """
+        receivers = None
+        if self.use_caching:
+            receivers = self.sender_receivers_cache.get(sender)
+            # We could end up here with NO_RECEIVERS even if we do check this case in
+            # .send() prior to calling _live_receivers() due to concurrent .send() call.
+            if receivers is NO_RECEIVERS:
+                return []
+        if receivers is None:
+            with self.lock:
+                senderkey = _make_id(sender)
+                receivers = []
+                for (receiverkey, r_senderkey), receiver in self.receivers:
+                    if r_senderkey == NONE_ID or r_senderkey == senderkey:
+                        receivers.append(receiver)
+                if self.use_caching:
+                    if not receivers:
+                        self.sender_receivers_cache[sender] = NO_RECEIVERS
+                    else:
+                        # Note, we must cache the weakref versions.
+                        self.sender_receivers_cache[sender] = receivers
+        non_weak_receivers = []
+        for receiver in receivers:
+            if isinstance(receiver, WEAKREF_TYPES):
+                # Dereference the weak reference.
+                receiver = receiver()
+                if receiver is not None:
+                    non_weak_receivers.append(receiver)
+            else:
+                non_weak_receivers.append(receiver)
+        return non_weak_receivers
+
+    def _remove_receiver(self, receiver):
+        """
+        Remove dead receivers from connections.
+        """
+
+        with self.lock:
+            to_remove = []
+            for key, connected_receiver in self.receivers:
+                if connected_receiver == receiver:
+                    to_remove.append(key)
+            for key in to_remove:
+                last_idx = len(self.receivers) - 1
+                # enumerate in reverse order so that indexes are valid even
+                # after we delete some items
+                for idx, (r_key, _) in enumerate(reversed(self.receivers)):
+                    if r_key == key:
+                        del self.receivers[last_idx - idx]
+            self.sender_receivers_cache.clear()
+
+
+def receiver(signal, **kwargs):
+    """
+    A decorator for connecting receivers to signals. Used by passing in the
+    signal (or list of signals) and keyword arguments to connect::
+
+        @receiver(post_save, sender=MyModel)
+        def signal_receiver(sender, **kwargs):
+            ...
+
+        @receiver([post_save, post_delete], sender=MyModel)
+        def signals_receiver(sender, **kwargs):
+            ...
+
+    """
+    def _decorator(func):
+        if isinstance(signal, (list, tuple)):
+            for s in signal:
+                s.connect(func, **kwargs)
+        else:
+            signal.connect(func, **kwargs)
+        return func
+    return _decorator
diff --git a/lib/python2.7/site-packages/django/dispatch/saferef.py b/lib/python2.7/site-packages/django/dispatch/saferef.py
new file mode 100644
index 0000000..c7731d4
--- /dev/null
+++ b/lib/python2.7/site-packages/django/dispatch/saferef.py
@@ -0,0 +1,257 @@
+"""
+"Safe weakrefs", originally from pyDispatcher.
+
+Provides a way to safely weakref any function, including bound methods (which
+aren't handled by the core weakref module).
+"""
+
+import traceback
+import weakref
+
+def safeRef(target, onDelete = None):
+    """Return a *safe* weak reference to a callable target
+
+    target -- the object to be weakly referenced, if it's a
+        bound method reference, will create a BoundMethodWeakref,
+        otherwise creates a simple weakref.
+    onDelete -- if provided, will have a hard reference stored
+        to the callable to be called after the safe reference
+        goes out of scope with the reference object, (either a
+        weakref or a BoundMethodWeakref) as argument.
+    """
+    if hasattr(target, '__self__'):
+        if target.__self__ is not None:
+            # Turn a bound method into a BoundMethodWeakref instance.
+            # Keep track of these instances for lookup by disconnect().
+            assert hasattr(target, '__func__'), """safeRef target %r has __self__, but no __func__, don't know how to create reference"""%( target,)
+            reference = get_bound_method_weakref(
+                target=target,
+                onDelete=onDelete
+            )
+            return reference
+    if callable(onDelete):
+        return weakref.ref(target, onDelete)
+    else:
+        return weakref.ref( target )
+
+class BoundMethodWeakref(object):
+    """'Safe' and reusable weak references to instance methods
+
+    BoundMethodWeakref objects provide a mechanism for
+    referencing a bound method without requiring that the
+    method object itself (which is normally a transient
+    object) is kept alive.  Instead, the BoundMethodWeakref
+    object keeps weak references to both the object and the
+    function which together define the instance method.
+
+    Attributes:
+        key -- the identity key for the reference, calculated
+            by the class's calculateKey method applied to the
+            target instance method
+        deletionMethods -- sequence of callable objects taking
+            single argument, a reference to this object which
+            will be called when *either* the target object or
+            target function is garbage collected (i.e. when
+            this object becomes invalid).  These are specified
+            as the onDelete parameters of safeRef calls.
+        weakSelf -- weak reference to the target object
+        weakFunc -- weak reference to the target function
+
+    Class Attributes:
+        _allInstances -- class attribute pointing to all live
+            BoundMethodWeakref objects indexed by the class's
+            calculateKey(target) method applied to the target
+            objects.  This weak value dictionary is used to
+            short-circuit creation so that multiple references
+            to the same (object, function) pair produce the
+            same BoundMethodWeakref instance.
+
+    """
+
+    _allInstances = weakref.WeakValueDictionary()
+
+    def __new__( cls, target, onDelete=None, *arguments,**named ):
+        """Create new instance or return current instance
+
+        Basically this method of construction allows us to
+        short-circuit creation of references to already-
+        referenced instance methods.  The key corresponding
+        to the target is calculated, and if there is already
+        an existing reference, that is returned, with its
+        deletionMethods attribute updated.  Otherwise the
+        new instance is created and registered in the table
+        of already-referenced methods.
+        """
+        key = cls.calculateKey(target)
+        current =cls._allInstances.get(key)
+        if current is not None:
+            current.deletionMethods.append( onDelete)
+            return current
+        else:
+            base = super( BoundMethodWeakref, cls).__new__( cls )
+            cls._allInstances[key] = base
+            base.__init__( target, onDelete, *arguments,**named)
+            return base
+
+    def __init__(self, target, onDelete=None):
+        """Return a weak-reference-like instance for a bound method
+
+        target -- the instance-method target for the weak
+            reference, must have __self__ and __func__ attributes
+            and be reconstructable via:
+                target.__func__.__get__( target.__self__ )
+            which is true of built-in instance methods.
+        onDelete -- optional callback which will be called
+            when this weak reference ceases to be valid
+            (i.e. either the object or the function is garbage
+            collected).  Should take a single argument,
+            which will be passed a pointer to this object.
+        """
+        def remove(weak, self=self):
+            """Set self.isDead to true when method or instance is destroyed"""
+            methods = self.deletionMethods[:]
+            del self.deletionMethods[:]
+            try:
+                del self.__class__._allInstances[ self.key ]
+            except KeyError:
+                pass
+            for function in methods:
+                try:
+                    if callable( function ):
+                        function( self )
+                except Exception as e:
+                    try:
+                        traceback.print_exc()
+                    except AttributeError:
+                        print('Exception during saferef %s cleanup function %s: %s' % (
+                            self, function, e)
+                        )
+        self.deletionMethods = [onDelete]
+        self.key = self.calculateKey( target )
+        self.weakSelf = weakref.ref(target.__self__, remove)
+        self.weakFunc = weakref.ref(target.__func__, remove)
+        self.selfName = str(target.__self__)
+        self.funcName = str(target.__func__.__name__)
+
+    def calculateKey( cls, target ):
+        """Calculate the reference key for this reference
+
+        Currently this is a two-tuple of the id()'s of the
+        target object and the target function respectively.
+        """
+        return (id(target.__self__),id(target.__func__))
+    calculateKey = classmethod( calculateKey )
+
+    def __str__(self):
+        """Give a friendly representation of the object"""
+        return """%s( %s.%s )"""%(
+            self.__class__.__name__,
+            self.selfName,
+            self.funcName,
+        )
+
+    __repr__ = __str__
+
+    def __hash__(self):
+        return hash(self.key)
+
+    def __bool__( self ):
+        """Whether we are still a valid reference"""
+        return self() is not None
+
+    def __nonzero__(self):      # Python 2 compatibility
+        return type(self).__bool__(self)
+
+    def __eq__(self, other):
+        """Compare with another reference"""
+        if not isinstance(other, self.__class__):
+            return self.__class__ == type(other)
+        return self.key == other.key
+
+    def __call__(self):
+        """Return a strong reference to the bound method
+
+        If the target cannot be retrieved, then will
+        return None, otherwise returns a bound instance
+        method for our object and function.
+
+        Note:
+            You may call this method any number of times,
+            as it does not invalidate the reference.
+        """
+        target = self.weakSelf()
+        if target is not None:
+            function = self.weakFunc()
+            if function is not None:
+                return function.__get__(target)
+        return None
+
+class BoundNonDescriptorMethodWeakref(BoundMethodWeakref):
+    """A specialized BoundMethodWeakref, for platforms where instance methods
+    are not descriptors.
+
+    It assumes that the function name and the target attribute name are the
+    same, instead of assuming that the function is a descriptor. This approach
+    is equally fast, but not 100% reliable because functions can be stored on an
+    attribute named differenty than the function's name such as in:
+
+    class A: pass
+    def foo(self): return "foo"
+    A.bar = foo
+
+    But this shouldn't be a common use case. So, on platforms where methods
+    aren't descriptors (such as Jython) this implementation has the advantage
+    of working in the most cases.
+    """
+    def __init__(self, target, onDelete=None):
+        """Return a weak-reference-like instance for a bound method
+
+        target -- the instance-method target for the weak
+            reference, must have __self__ and __func__ attributes
+            and be reconstructable via:
+                target.__func__.__get__( target.__self__ )
+            which is true of built-in instance methods.
+        onDelete -- optional callback which will be called
+            when this weak reference ceases to be valid
+            (i.e. either the object or the function is garbage
+            collected).  Should take a single argument,
+            which will be passed a pointer to this object.
+        """
+        assert getattr(target.__self__, target.__name__) == target, \
+               ("method %s isn't available as the attribute %s of %s" %
+                (target, target.__name__, target.__self__))
+        super(BoundNonDescriptorMethodWeakref, self).__init__(target, onDelete)
+
+    def __call__(self):
+        """Return a strong reference to the bound method
+
+        If the target cannot be retrieved, then will
+        return None, otherwise returns a bound instance
+        method for our object and function.
+
+        Note:
+            You may call this method any number of times,
+            as it does not invalidate the reference.
+        """
+        target = self.weakSelf()
+        if target is not None:
+            function = self.weakFunc()
+            if function is not None:
+                # Using partial() would be another option, but it erases the
+                # "signature" of the function. That is, after a function is
+                # curried, the inspect module can't be used to determine how
+                # many arguments the function expects, nor what keyword
+                # arguments it supports, and pydispatcher needs this
+                # information.
+                return getattr(target, function.__name__)
+        return None
+
+def get_bound_method_weakref(target, onDelete):
+    """Instantiates the appropiate BoundMethodWeakRef, depending on the details of
+    the underlying class method implementation"""
+    if hasattr(target, '__get__'):
+        # target method is a descriptor, so the default implementation works:
+        return BoundMethodWeakref(target=target, onDelete=onDelete)
+    else:
+        # no luck, use the alternative implementation:
+        return BoundNonDescriptorMethodWeakref(target=target, onDelete=onDelete)