diff options
Diffstat (limited to 'lib/python2.7/site-packages/django/dispatch')
3 files changed, 0 insertions, 572 deletions
diff --git a/lib/python2.7/site-packages/django/dispatch/__init__.py b/lib/python2.7/site-packages/django/dispatch/__init__.py deleted file mode 100644 index 9aeb83c..0000000 --- a/lib/python2.7/site-packages/django/dispatch/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -"""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 deleted file mode 100644 index d26433a..0000000 --- a/lib/python2.7/site-packages/django/dispatch/dispatcher.py +++ /dev/null @@ -1,306 +0,0 @@ -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 deleted file mode 100644 index c7731d4..0000000 --- a/lib/python2.7/site-packages/django/dispatch/saferef.py +++ /dev/null @@ -1,257 +0,0 @@ -""" -"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) |