/django/dispatch/dispatcher.py

https://code.google.com/p/mango-py/ · Python · 270 lines · 110 code · 23 blank · 137 comment · 42 complexity · a6bb4376f16fe1d41c290287e5f70287 MD5 · raw file

  1. import weakref
  2. import threading
  3. from django.dispatch import saferef
  4. WEAKREF_TYPES = (weakref.ReferenceType, saferef.BoundMethodWeakref)
  5. def _make_id(target):
  6. if hasattr(target, 'im_func'):
  7. return (id(target.im_self), id(target.im_func))
  8. return id(target)
  9. class Signal(object):
  10. """
  11. Base class for all signals
  12. Internal attributes:
  13. receivers
  14. { receriverkey (id) : weakref(receiver) }
  15. """
  16. def __init__(self, providing_args=None):
  17. """
  18. Create a new signal.
  19. providing_args
  20. A list of the arguments this signal can pass along in a send() call.
  21. """
  22. self.receivers = []
  23. if providing_args is None:
  24. providing_args = []
  25. self.providing_args = set(providing_args)
  26. self.lock = threading.Lock()
  27. def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
  28. """
  29. Connect receiver to sender for signal.
  30. Arguments:
  31. receiver
  32. A function or an instance method which is to receive signals.
  33. Receivers must be hashable objects.
  34. If weak is True, then receiver must be weak-referencable (more
  35. precisely saferef.safeRef() must be able to create a reference
  36. to the receiver).
  37. Receivers must be able to accept keyword arguments.
  38. If receivers have a dispatch_uid attribute, the receiver will
  39. not be added if another receiver already exists with that
  40. dispatch_uid.
  41. sender
  42. The sender to which the receiver should respond. Must either be
  43. of type Signal, or None to receive events from any sender.
  44. weak
  45. Whether to use weak references to the receiver. By default, the
  46. module will attempt to use weak references to the receiver
  47. objects. If this parameter is false, then strong references will
  48. be used.
  49. dispatch_uid
  50. An identifier used to uniquely identify a particular instance of
  51. a receiver. This will usually be a string, though it may be
  52. anything hashable.
  53. """
  54. from django.conf import settings
  55. # If DEBUG is on, check that we got a good receiver
  56. if settings.DEBUG:
  57. import inspect
  58. assert callable(receiver), "Signal receivers must be callable."
  59. # Check for **kwargs
  60. # Not all callables are inspectable with getargspec, so we'll
  61. # try a couple different ways but in the end fall back on assuming
  62. # it is -- we don't want to prevent registration of valid but weird
  63. # callables.
  64. try:
  65. argspec = inspect.getargspec(receiver)
  66. except TypeError:
  67. try:
  68. argspec = inspect.getargspec(receiver.__call__)
  69. except (TypeError, AttributeError):
  70. argspec = None
  71. if argspec:
  72. assert argspec[2] is not None, \
  73. "Signal receivers must accept keyword arguments (**kwargs)."
  74. if dispatch_uid:
  75. lookup_key = (dispatch_uid, _make_id(sender))
  76. else:
  77. lookup_key = (_make_id(receiver), _make_id(sender))
  78. if weak:
  79. receiver = saferef.safeRef(receiver, onDelete=self._remove_receiver)
  80. self.lock.acquire()
  81. try:
  82. for r_key, _ in self.receivers:
  83. if r_key == lookup_key:
  84. break
  85. else:
  86. self.receivers.append((lookup_key, receiver))
  87. finally:
  88. self.lock.release()
  89. def disconnect(self, receiver=None, sender=None, weak=True, dispatch_uid=None):
  90. """
  91. Disconnect receiver from sender for signal.
  92. If weak references are used, disconnect need not be called. The receiver
  93. will be remove from dispatch automatically.
  94. Arguments:
  95. receiver
  96. The registered receiver to disconnect. May be none if
  97. dispatch_uid is specified.
  98. sender
  99. The registered sender to disconnect
  100. weak
  101. The weakref state to disconnect
  102. dispatch_uid
  103. the unique identifier of the receiver to disconnect
  104. """
  105. if dispatch_uid:
  106. lookup_key = (dispatch_uid, _make_id(sender))
  107. else:
  108. lookup_key = (_make_id(receiver), _make_id(sender))
  109. self.lock.acquire()
  110. try:
  111. for index in xrange(len(self.receivers)):
  112. (r_key, _) = self.receivers[index]
  113. if r_key == lookup_key:
  114. del self.receivers[index]
  115. break
  116. finally:
  117. self.lock.release()
  118. def send(self, sender, **named):
  119. """
  120. Send signal from sender to all connected receivers.
  121. If any receiver raises an error, the error propagates back through send,
  122. terminating the dispatch loop, so it is quite possible to not have all
  123. receivers called if a raises an error.
  124. Arguments:
  125. sender
  126. The sender of the signal Either a specific object or None.
  127. named
  128. Named arguments which will be passed to receivers.
  129. Returns a list of tuple pairs [(receiver, response), ... ].
  130. """
  131. responses = []
  132. if not self.receivers:
  133. return responses
  134. for receiver in self._live_receivers(_make_id(sender)):
  135. response = receiver(signal=self, sender=sender, **named)
  136. responses.append((receiver, response))
  137. return responses
  138. def send_robust(self, sender, **named):
  139. """
  140. Send signal from sender to all connected receivers catching errors.
  141. Arguments:
  142. sender
  143. The sender of the signal. Can be any python object (normally one
  144. registered with a connect if you actually want something to
  145. occur).
  146. named
  147. Named arguments which will be passed to receivers. These
  148. arguments must be a subset of the argument names defined in
  149. providing_args.
  150. Return a list of tuple pairs [(receiver, response), ... ]. May raise
  151. DispatcherKeyError.
  152. If any receiver raises an error (specifically any subclass of
  153. Exception), the error instance is returned as the result for that
  154. receiver.
  155. """
  156. responses = []
  157. if not self.receivers:
  158. return responses
  159. # Call each receiver with whatever arguments it can accept.
  160. # Return a list of tuple pairs [(receiver, response), ... ].
  161. for receiver in self._live_receivers(_make_id(sender)):
  162. try:
  163. response = receiver(signal=self, sender=sender, **named)
  164. except Exception, err:
  165. responses.append((receiver, err))
  166. else:
  167. responses.append((receiver, response))
  168. return responses
  169. def _live_receivers(self, senderkey):
  170. """
  171. Filter sequence of receivers to get resolved, live receivers.
  172. This checks for weak references and resolves them, then returning only
  173. live receivers.
  174. """
  175. none_senderkey = _make_id(None)
  176. receivers = []
  177. for (receiverkey, r_senderkey), receiver in self.receivers:
  178. if r_senderkey == none_senderkey or r_senderkey == senderkey:
  179. if isinstance(receiver, WEAKREF_TYPES):
  180. # Dereference the weak reference.
  181. receiver = receiver()
  182. if receiver is not None:
  183. receivers.append(receiver)
  184. else:
  185. receivers.append(receiver)
  186. return receivers
  187. def _remove_receiver(self, receiver):
  188. """
  189. Remove dead receivers from connections.
  190. """
  191. self.lock.acquire()
  192. try:
  193. to_remove = []
  194. for key, connected_receiver in self.receivers:
  195. if connected_receiver == receiver:
  196. to_remove.append(key)
  197. for key in to_remove:
  198. last_idx = len(self.receivers) - 1
  199. # enumerate in reverse order so that indexes are valid even
  200. # after we delete some items
  201. for idx, (r_key, _) in enumerate(reversed(self.receivers)):
  202. if r_key == key:
  203. del self.receivers[last_idx-idx]
  204. finally:
  205. self.lock.release()
  206. def receiver(signal, **kwargs):
  207. """
  208. A decorator for connecting receivers to signals. Used by passing in the
  209. signal and keyword arguments to connect::
  210. @receiver(post_save, sender=MyModel)
  211. def signal_receiver(sender, **kwargs):
  212. ...
  213. """
  214. def _decorator(func):
  215. signal.connect(func, **kwargs)
  216. return func
  217. return _decorator