class Publisher(SignalLogger):
"""Base class for signaling Publisher.
The base __init__ function setups the signaling object that a Subscriber can connect to.
"""
def __init__(self):
"""Setups signaling object.
"""
super().__init__()
self._signal = Signal()
def subscribe(self, handle):
"""Subscribe a handle to this publisher.
"""
self._signal.connect(handle)
def unsubscribe(self, handle):
"""Unsubscribe a handle from this publisher.
"""
self._signal.disconnect(handle)
def emit(self, **kwargs):
"""Emits arguments to the subscribers.
"""
self._signal.send(sender=self, **kwargs)
class SignalHookTest(SpyAgency, TestCase):
"""Unit tests for djblets.extensions.hooks.SignalHook."""
def setUp(self):
manager = ExtensionManager('')
self.test_extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.patterns = patterns('',
(r'^url_hook_test/', include('djblets.extensions.test.urls')))
self.signal = Signal()
self.spy_on(self._on_signal_fired)
def test_initialize(self):
"""Testing SignalHook initialization connects to signal"""
SignalHook(self.test_extension, self.signal, self._on_signal_fired)
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 1)
def test_shutdown(self):
"""Testing SignalHook.shutdown disconnects from signal"""
hook = SignalHook(self.test_extension, self.signal,
self._on_signal_fired)
hook.shutdown()
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 0)
def _on_signal_fired(self, *args, **kwargs):
pass
def test_signals_reenabled_on_exception(self, signal: Signal) -> None:
try:
with disable_signals([signal]):
raise ValueError("test")
except ValueError:
pass
signal.send(sender=None, message="re-enabled")
assert self.messages == ["re-enabled"]
def _project_create_update(request, project_slug=None, template_name="projects/project_form.html"):
"""
Handler for creating and updating a project.
This function helps to eliminate duplication of code between those two
actions, and also allows to apply different permission checks in the
respective views.
"""
if project_slug:
project = get_object_or_404(Project, slug=project_slug)
else:
project = None
if request.method == "POST":
project_form = ProjectForm(request.POST, instance=project, prefix="project")
if project_form.is_valid():
project = project_form.save(commit=False)
project_id = project.id
# Only here the owner is written to the project model
if not project_id:
project.owner = request.user
# provide the form data to any signal handlers before project_save
Signal.send(signals.pre_proj_save, sender=Project, instance=project, form=project_form)
project.save()
project_form.save_m2m()
# TODO: Not sure if here is the best place to put it
Signal.send(signals.post_proj_save_m2m, sender=Project, instance=project, form=project_form)
# ActionLog & Notification
context = {"project": project}
if not project_id:
nt = "project_added"
action_logging(request.user, [project], nt, context=context)
else:
nt = "project_changed"
action_logging(request.user, [project], nt, context=context)
if settings.ENABLE_NOTICES:
txnotification.send_observation_notices_for(project, signal=nt, extra_context=context)
return HttpResponseRedirect(reverse("project_detail", args=[project.slug]))
else:
# Make the current user the maintainer when adding a project
if project:
initial_data = {}
else:
initial_data = {"maintainers": [request.user.pk]}
project_form = ProjectForm(instance=project, prefix="project", initial=initial_data)
return render_to_response(
template_name, {"project_form": project_form, "project": project}, context_instance=RequestContext(request)
)
def test_signal(self):
action = Signal(providing_args=[
'verb', 'target', 'description'
])
def action_handler(verb, target, **kwargs):
kwargs.pop('signal')
sender = kwargs.pop('sender')
print(sender, verb, target, kwargs)
action.connect(action_handler, dispatch_uid='qevent.test')
def action_event(verb, target, **kwargs):
kwargs.pop('signal')
print(verb, kwargs)
action.connect(action_event, dispatch_uid='qevent.test2')
action.send('Alice', verb='say', target='Bob', description='Hello')
def test_other_signals_always_enabled(self, signal: Signal) -> None:
self.other_message = None
def listener(signal: Signal, sender, message: str) -> None:
self.other_message = message
other_signal = Signal()
other_signal.connect(listener)
with disable_signals([signal]):
other_signal.send(sender=None, message="always_enabled")
assert len(self.messages) == 0
assert self.other_message == "always_enabled"
def test_mock_receiver(self):
signal = Signal()
with mock_signal_receiver(signal) as receiver:
signal.send(sender=None)
self.assertEqual(receiver.call_count, 1)
sentinel = {}
def side_effect(*args, **kwargs):
return sentinel
with mock_signal_receiver(signal, wraps=side_effect) as receiver:
responses = signal.send(sender=None)
self.assertEqual(receiver.call_count, 1)
# Signals respond with a list of tuple pairs [(receiver, response), ...]
self.assertIs(responses[0][1], sentinel)
def test_mock_receiver(self):
signal = Signal()
with mock_signal_receiver(signal) as receiver:
signal.send(sender=None)
self.assertEqual(receiver.call_count, 1)
sentinel = {}
def side_effect(*args, **kwargs):
return sentinel
with mock_signal_receiver(signal, wraps=side_effect) as receiver:
responses = signal.send(sender=None)
self.assertEqual(receiver.call_count, 1)
# Signals respond with a list of tuple pairs [(receiver, response), ...]
self.assertIs(responses[0][1], sentinel)
class Channel(object):
def __init__(self, name, providing_args):
self.name = name
self.signal = Signal(providing_args=providing_args)
def __str__(self):
return str(self.name)
def __unicode__(self):
return unicode(self.name)
def __repr__(self):
return '<Channel: {0}>'.format(self.name)
def publish(self, **kwargs):
"Publishes to the channel which notifies all connected handlers."
log.debug('Publish to {0}'.format(self))
self.signal.send(sender=self.name, **kwargs)
def subscribe(self, receiver):
"Subscribes an external handler to this channel."
log.debug('{0}.{1} subscribe to {2}'.format(receiver.__module__, receiver.__name__, self))
self.signal.connect(receiver)
class Channel(object):
def __init__(self, name, providing_args):
self.name = name
self.signal = Signal(providing_args=providing_args)
def __str__(self):
return str(self.name)
def __unicode__(self):
return unicode(self.name)
def __repr__(self):
return '<Channel: {0}>'.format(self.name)
def publish(self, **kwargs):
"Publishes to the channel which notifies all connected handlers."
log.debug('Publish to {0}'.format(self))
self.signal.send(sender=self.name, **kwargs)
def subscribe(self, receiver):
"Subscribes an external handler to this channel."
log.debug('{0}.{1} subscribe to {2}'.format(receiver.__module__,
receiver.__name__, self))
self.signal.connect(receiver)
class Node(MPTTModel):
full_name = models.CharField(max_length=32,
verbose_name=_("full name"),
help_text=_("Shown in the navigation menu."),
validators=[validate_whitespaces])
short_name = models.CharField(max_length=32,
verbose_name=_("short name"),
help_text=_("Shown in the URL."),
validators=[validate_db_string_id])
parent = TreeForeignKey('self',
null=True,
blank=False,
related_name='children',
verbose_name=_("parent"))
panel_code = models.TextField(null=False,
blank=True,
verbose_name=_("panel code"))
problems_in_content = models.ManyToManyField('problems.problem',
blank=True)
class Meta(object):
unique_together = (('parent', 'short_name'), )
def __init__(self, *args, **kwargs):
super(Node, self).__init__(*args, **kwargs)
self._path = None
self._connected_parent = None
self._path_changed = Signal(providing_args=['path'])
def save(self, *args, **kwargs):
super(Node, self).save(*args, **kwargs)
if self._path is not None:
old_path = self._path
self._path = None
new_path = self.get_path()
if old_path != new_path:
self._path_changed.send(self, path=new_path)
def __unicode__(self):
return self.full_name
def get_siblings(self, include_self=False):
if self.is_root_node():
if include_self:
return Node.objects.filter(pk=self.pk)
else:
return Node.objects.none()
else:
return super(Node, self).get_siblings(include_self)
def get_ancestors_including_self(self):
return self.get_ancestors(include_self=True)
def get_siblings_including_self(self):
return self.get_siblings(include_self=True)
def get_path(self):
if self._path is None:
if self.is_root_node():
self._path = self.short_name
else:
self._path = join_paths(self.parent.get_path(),
self.short_name)
if self._connected_parent != self.parent:
if self._connected_parent is not None:
self._connected_parent._path_changed.disconnect(
self._parent_path_changed_callback)
if self.parent is not None:
self.parent._path_changed.connect(
self._parent_path_changed_callback)
self._connected_parent = self.parent
return self._path
def _parent_path_changed_callback(self, sender, path, **kwargs):
self._path = join_paths(path, self.short_name)
self._path_changed.send(self, path=self._path)
class Node(MPTTModel):
short_name = models.CharField(max_length=32, verbose_name=_("short name"),
help_text=_("Shown in the URL."),
validators=[validate_db_string_id])
parent = TreeForeignKey('self', null=True, blank=False,
related_name='children', verbose_name=_("parent"),
on_delete=models.CASCADE)
problems_in_content = models.ManyToManyField('problems.problem',
blank=True)
class Meta(object):
unique_together = (('parent', 'short_name'),)
def __init__(self, *args, **kwargs):
super(Node, self).__init__(*args, **kwargs)
self._path = None
self._connected_parent = None
self._path_changed = Signal(providing_args=['path'])
def save(self, *args, **kwargs):
super(Node, self).save(*args, **kwargs)
if self._path is not None:
old_path = self._path
self._path = None
new_path = self.get_path()
if old_path != new_path:
self._path_changed.send(self, path=new_path)
def __unicode__(self):
return self.get_lang_version().full_name
# Tries to get a default language version for a current context (from
# a given request, then a current thread and then from the settings). If
# none matching version could be found, just return any.
def get_lang_version(self, request=None):
if request is not None:
lang = get_language_from_request(request)
try:
return self.language_versions.get(language=lang)
except NodeLanguageVersion.DoesNotExist:
pass
try:
return self.language_versions.get(language=get_language())
except NodeLanguageVersion.DoesNotExist:
pass
try:
return self.language_versions.get(language=settings.LANGUAGE_CODE)
except NodeLanguageVersion.DoesNotExist:
pass
return self.language_versions.first()
def get_siblings(self, include_self=False):
if self.is_root_node():
if include_self:
return Node.objects.filter(pk=self.pk)
else:
return Node.objects.none()
else:
return super(Node, self).get_siblings(include_self)
def get_ancestors_including_self(self):
return self.get_ancestors(include_self=True)
def get_siblings_including_self(self):
return self.get_siblings(include_self=True)
def get_path(self):
if self._path is None:
if self.is_root_node():
self._path = self.short_name
else:
self._path = join_paths(self.parent.get_path(),
self.short_name)
if self._connected_parent != self.parent:
if self._connected_parent is not None:
self._connected_parent._path_changed.disconnect(
self._parent_path_changed_callback)
if self.parent is not None:
self.parent._path_changed.connect(
self._parent_path_changed_callback)
self._connected_parent = self.parent
return self._path
def _parent_path_changed_callback(self, sender, path, **kwargs):
self._path = join_paths(path, self.short_name)
self._path_changed.send(self, path=self._path)
print("---start init %s table---" % obj)
for one in tmp_list:
obj.objects.create(parent_id=one[1], key=one[0], value=one[-1])
print("---init %s complate---" % obj)
"""
这个必须放在management.py, 这样在python manage.py migrate时才会运行
"""
# 初始化一个信号
obj_single = Signal(providing_args=["remarks"])
@receiver(obj_single)
def init_dict_table(sender, **kwargs):
# 初始化其他字典表
for one in map_list:
init_dict_table_content(one[0], one[1])
# 初始化服务内容字典表
init_service_content_table(ServiceContentMap, ServiceContent)
# 监测是否字典表已经初始化了
try:
if not UnitNature.objects.all():
obj_single.send(sender=None, remarks="init db dict tables")
except Exception as e:
print("init db exception!")
class Node(MPTTModel):
short_name = models.CharField(max_length=32,
verbose_name=_("short name"),
help_text=_("Shown in the URL."),
validators=[validate_db_string_id])
parent = TreeForeignKey('self',
null=True,
blank=False,
related_name='children',
verbose_name=_("parent"))
problems_in_content = models.ManyToManyField('problems.problem',
blank=True)
class Meta(object):
unique_together = (('parent', 'short_name'), )
def __init__(self, *args, **kwargs):
super(Node, self).__init__(*args, **kwargs)
self._path = None
self._connected_parent = None
self._path_changed = Signal(providing_args=['path'])
def save(self, *args, **kwargs):
super(Node, self).save(*args, **kwargs)
if self._path is not None:
old_path = self._path
self._path = None
new_path = self.get_path()
if old_path != new_path:
self._path_changed.send(self, path=new_path)
def __unicode__(self):
return self.get_lang_version().full_name
# Tries to get a default language version for a current context (from
# a given request, then a current thread and then from the settings). If
# none matching version could be found, just return any.
def get_lang_version(self, request=None):
if request is not None:
lang = get_language_from_request(request)
try:
return self.language_versions.get(language=lang)
except NodeLanguageVersion.DoesNotExist:
pass
try:
return self.language_versions.get(language=get_language())
except NodeLanguageVersion.DoesNotExist:
pass
try:
return self.language_versions.get(language=settings.LANGUAGE_CODE)
except NodeLanguageVersion.DoesNotExist:
pass
return self.language_versions.first()
def get_siblings(self, include_self=False):
if self.is_root_node():
if include_self:
return Node.objects.filter(pk=self.pk)
else:
return Node.objects.none()
else:
return super(Node, self).get_siblings(include_self)
def get_ancestors_including_self(self):
return self.get_ancestors(include_self=True)
def get_siblings_including_self(self):
return self.get_siblings(include_self=True)
def get_path(self):
if self._path is None:
if self.is_root_node():
self._path = self.short_name
else:
self._path = join_paths(self.parent.get_path(),
self.short_name)
if self._connected_parent != self.parent:
if self._connected_parent is not None:
self._connected_parent._path_changed.disconnect(
self._parent_path_changed_callback)
if self.parent is not None:
self.parent._path_changed.connect(
self._parent_path_changed_callback)
self._connected_parent = self.parent
return self._path
def _parent_path_changed_callback(self, sender, path, **kwargs):
self._path = join_paths(path, self.short_name)
self._path_changed.send(self, path=self._path)
class SignalHookTests(SpyAgency, TestCase):
"""Unit tests for djblets.extensions.hooks.SignalHook."""
def setUp(self):
manager = ExtensionManager('')
self.test_extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.signal = Signal()
self.spy_on(self._on_signal_fired)
self.spy_on(self._on_signal_exception)
def test_initialize(self):
"""Testing SignalHook initialization connects to signal"""
SignalHook(self.test_extension, self.signal, self._on_signal_fired)
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 1)
def test_shutdown(self):
"""Testing SignalHook.shutdown disconnects from signal"""
hook = SignalHook(self.test_extension, self.signal,
self._on_signal_fired)
hook.shutdown()
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 0)
def test_shutdown_with_sender(self):
"""Testing SignalHook.shutdown disconnects when a sender was set"""
hook = SignalHook(self.test_extension,
self.signal,
self._on_signal_fired,
sender=self)
hook.shutdown()
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 0)
def test_forwards_args(self):
"""Testing SignalHook forwards arguments to callback"""
seen_kwargs = {}
def callback(**kwargs):
seen_kwargs.update(kwargs)
SignalHook(self.test_extension, self.signal, callback)
self.signal.send(sender=self, foo=1, bar=2)
self.assertTrue('foo', seen_kwargs)
self.assertEqual(seen_kwargs['foo'], 1)
self.assertTrue('bar', seen_kwargs)
self.assertEqual(seen_kwargs['bar'], 2)
def test_sandbox_errors_true(self):
"""Testing SignalHook with sandbox_errors set to True logs errors"""
SignalHook(self.test_extension,
self.signal,
self._on_signal_exception,
sandbox_errors=True)
self.assertEqual(len(self._on_signal_exception.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_exception.calls), 1)
def test_sandbox_errors_false(self):
"""Testing SignalHook with sandbox_errors set to False"""
SignalHook(self.test_extension,
self.signal,
self._on_signal_exception,
sandbox_errors=False)
self.assertEqual(len(self._on_signal_exception.calls), 0)
self.assertRaises(Exception, self.signal.send, self)
self.assertEqual(len(self._on_signal_exception.calls), 1)
def _on_signal_fired(self, *args, **kwargs):
pass
def _on_signal_exception(self, *args, **kwargs):
raise Exception
class Node(MPTTModel):
full_name = models.CharField(max_length=32, verbose_name=_("full name"),
help_text=_("Shown in the navigation menu."),
validators=[validate_whitespaces])
short_name = models.CharField(max_length=32, verbose_name=_("short name"),
help_text=_("Shown in the URL."),
validators=[validate_db_string_id])
parent = TreeForeignKey('self', null=True, blank=False,
related_name='children', verbose_name=_("parent"))
panel_code = models.TextField(null=False, blank=True,
verbose_name=_("panel code"))
problems_in_content = models.ManyToManyField('problems.problem',
blank=True)
class Meta(object):
unique_together = (('parent', 'short_name'),)
def __init__(self, *args, **kwargs):
super(Node, self).__init__(*args, **kwargs)
self._path = None
self._connected_parent = None
self._path_changed = Signal(providing_args=['path'])
def save(self, *args, **kwargs):
super(Node, self).save(*args, **kwargs)
if self._path is not None:
old_path = self._path
self._path = None
new_path = self.get_path()
if old_path != new_path:
self._path_changed.send(self, path=new_path)
def __unicode__(self):
return self.full_name
def get_siblings(self, include_self=False):
if self.is_root_node():
if include_self:
return Node.objects.filter(pk=self.pk)
else:
return Node.objects.none()
else:
return super(Node, self).get_siblings(include_self)
def get_ancestors_including_self(self):
return self.get_ancestors(include_self=True)
def get_siblings_including_self(self):
return self.get_siblings(include_self=True)
def get_path(self):
if self._path is None:
if self.is_root_node():
self._path = self.short_name
else:
self._path = join_paths(self.parent.get_path(),
self.short_name)
if self._connected_parent != self.parent:
if self._connected_parent is not None:
self._connected_parent._path_changed.disconnect(
self._parent_path_changed_callback)
if self.parent is not None:
self.parent._path_changed.connect(
self._parent_path_changed_callback)
self._connected_parent = self.parent
return self._path
def _parent_path_changed_callback(self, sender, path, **kwargs):
self._path = join_paths(path, self.short_name)
self._path_changed.send(self, path=self._path)
def _project_create_update(request,
project_slug=None,
template_name='projects/project_form.html'):
"""
Handler for creating and updating a project.
This function helps to eliminate duplication of code between those two
actions, and also allows to apply different permission checks in the
respective views.
"""
if project_slug:
project = get_object_or_404(Project, slug=project_slug)
else:
project = None
if request.method == 'POST':
owner = project and project.owner or request.user
project_form = ProjectForm(request.POST,
request.FILES,
instance=project,
prefix='project',
owner=owner)
if project_form.is_valid():
project = project_form.save(commit=False)
project_id = project.id
# Only here the owner is written to the project model
if not project_id:
project.owner = request.user
# provide the form data to any signal handlers before project_save
Signal.send(signals.pre_proj_save,
sender=Project,
instance=project,
form=project_form)
project.save()
project_form.save_m2m()
# TODO: Not sure if here is the best place to put it
Signal.send(signals.post_proj_save_m2m,
sender=Project,
instance=project,
form=project_form)
# ActionLog & Notification
context = {'project': project, 'sender': request.user}
if not project_id:
nt = 'project_added'
action_logging(request.user, [project], nt, context=context)
else:
nt = 'project_changed'
action_logging(request.user, [project], nt, context=context)
if settings.ENABLE_NOTICES:
txnotification.send_observation_notices_for(
project, signal=nt, extra_context=context)
return HttpResponseRedirect(
reverse('project_detail', args=[project.slug]), )
else:
# Make the current user the maintainer when adding a project
if project:
initial_data = {}
else:
initial_data = {"maintainers": [request.user.pk]}
project_form = ProjectForm(instance=project,
prefix='project',
initial=initial_data)
return render_to_response(template_name, {
'project_form': project_form,
'project': project,
},
context_instance=RequestContext(request))
class MqttClient(object):
"""docstring for MqttClient"""
def __init__(self):
super(MqttClient, self).__init__()
self.signal = Signal(
providing_args=["message", "txInfo", "rxInfo", "signalCount"])
self.client = mqtt.Client(transport="tcp")
self.client.on_connect = self.on_connect
self.client.on_message = self.on_message
self.signal_count = False
self.client.username_pw_set(username=os.environ.get("MQTT_USERNAME"),
password=os.environ.get("MQTT_PASSWORD"))
self.client.connect_async(os.environ.get("MQTT_HOST"),
int(os.environ.get("MQTT_PORT")),
int(os.environ.get("MQTT_KEEPALIVE")))
self.client.loop_start()
def getSignal(self):
return self.signal
def on_connect(self, client, userdata, flags, rc):
print("Connected to ", os.environ.get("MQTT_HOST"))
client.subscribe('data')
def on_message(self, client, userdata, message):
try:
payload = json.loads(message.payload.decode('utf-8'))
txInfo = payload.pop('txInfo')
if isinstance(txInfo, list):
txInfo = txInfo[0]
rxInfo = payload.pop('rxInfo')
if isinstance(rxInfo, list):
rxInfo = rxInfo[0]
message = dict((key, value) for key, value in payload.items()
if key not in ['txInfo', 'rxInfo'])
self.signal_count = not self.signal_count
self.signal.send(sender=self.__class__,
message=message,
txInfo=txInfo,
rxInfo=rxInfo,
signalCount=self.signal_count)
client.publish('response', payload="Message recieved Capitain!")
except (ValueError, KeyError, TypeError) as e:
print("JSON error:\n", e)
def exit(self):
self.client.loop_stop()
def __del__(self):
self.exit()
def signalRecieved(self, parity):
if parity == self.signal_count:
self.signal_count = not self.signal_count
return True
return False
continue
except FormatError, error:
pass
yield cls, result, text, error
break
# stop when there's no more text to parse
if not remaining:
break
def route(self, message):
"""Route the message provided."""
for cls, result, text, error in self.parse(message.text):
erroneous = bool(error)
form = cls(text=text, message=message, erroneous=erroneous)
form.save()
if result is not None:
pre_handle.send(sender=form, result=result, error=error)
error = None
try:
form.handle(**result)
except Exception, error:
raise
finally:
post_handle.send(sender=form, error=error)
elif error is not None:
form.reply(error.text)
class SignalHookTests(SpyAgency, TestCase):
"""Unit tests for djblets.extensions.hooks.SignalHook."""
def setUp(self):
manager = ExtensionManager('')
self.test_extension = \
TestExtensionWithRegistration(extension_manager=manager)
self.signal = Signal()
self.spy_on(self._on_signal_fired)
self.spy_on(self._on_signal_exception)
def test_initialize(self):
"""Testing SignalHook initialization connects to signal"""
SignalHook(self.test_extension, self.signal, self._on_signal_fired)
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 1)
def test_shutdown(self):
"""Testing SignalHook.shutdown disconnects from signal"""
hook = SignalHook(self.test_extension, self.signal,
self._on_signal_fired)
hook.shutdown()
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 0)
def test_shutdown_with_sender(self):
"""Testing SignalHook.shutdown disconnects when a sender was set"""
hook = SignalHook(self.test_extension, self.signal,
self._on_signal_fired, sender=self)
hook.shutdown()
self.assertEqual(len(self._on_signal_fired.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_fired.calls), 0)
def test_forwards_args(self):
"""Testing SignalHook forwards arguments to callback"""
seen_kwargs = {}
def callback(**kwargs):
seen_kwargs.update(kwargs)
SignalHook(self.test_extension, self.signal, callback)
self.signal.send(sender=self, foo=1, bar=2)
self.assertTrue('foo', seen_kwargs)
self.assertEqual(seen_kwargs['foo'], 1)
self.assertTrue('bar', seen_kwargs)
self.assertEqual(seen_kwargs['bar'], 2)
def test_sandbox_errors_true(self):
"""Testing SignalHook with sandbox_errors set to True logs errors"""
SignalHook(self.test_extension, self.signal, self._on_signal_exception,
sandbox_errors=True)
self.assertEqual(len(self._on_signal_exception.calls), 0)
self.signal.send(self)
self.assertEqual(len(self._on_signal_exception.calls), 1)
def test_sandbox_errors_false(self):
"""Testing SignalHook with sandbox_errors set to False"""
SignalHook(self.test_extension, self.signal, self._on_signal_exception,
sandbox_errors=False)
self.assertEqual(len(self._on_signal_exception.calls), 0)
self.assertRaises(Exception, self.signal.send, self)
self.assertEqual(len(self._on_signal_exception.calls), 1)
def _on_signal_fired(self, *args, **kwargs):
pass
def _on_signal_exception(self, *args, **kwargs):
raise Exception
except FormatError, error:
pass
except Exception, exc: # pragma: NOCOVER
# backwards compatible with older version of
# picoparse; this is equivalent to not
# matching
if "Commit / cut called" in str(exc):
continue
raise
else:
result = result or {}
remaining = "".join(remaining)
message.__class__ = model
message.__init__(text=message.text, time=time)
post_parse.send(sender=message, error=error)
break
# make sure we have a peer record for this sender
message.uri = "%s://%s" % (self.name, ident)
peer, created = Peer.objects.get_or_create(uri=message.uri)
if created:
peer.save()
# set error text if applicable
if error is not None:
message.erroneous = True
else:
message.erroneous = False
# save message before calling handler and append to
return self
def append_attr(self, name, value):
def process(widget, attrs, name, value):
if attrs.get(name):
attrs[name] += ' ' + value
else:
attrs[name] = value
self._process_attributes(name, value, process)
return self
def add_class(self, value):
return self.append_attr('class', value)
def add_error_class(self, value):
if hasattr(self.field, 'errors') and self.field.errors:
return self.add_class(value)
return self
def set_data(self, name, value):
return self.attr('data-' + name, value)
# Give other parts of the code a chance to register custom functions on boundfield
boundfield_props.send(sender = BoundField)
setattr(forms, 'BoundField', BoundField)
def test_signals_disabled_during(self, signal: Signal) -> None:
assert len(self.messages) == 0
with disable_signals([signal]):
signal.send(sender=None, message="disabled")
assert len(self.messages) == 0
def test_signals_reenabled_after(self, signal: Signal) -> None:
assert len(self.messages) == 0
with disable_signals([signal]):
pass
signal.send(sender=None, message="re-enabled")
assert self.messages == ["re-enabled"]
response = error.text
except StopError, error:
# this does not mean the message was erroneous; we
# just extract the (optional) response
response = error.text
except Exception, error:
# catch and re-raise to allow the ``post_handle``
# signal to receive the exception instance
raise
if response is not None:
text = unicode(response)
request.respond(message.connection, text)
if error is not None:
break
finally:
post_handle.send(sender=request, error=error)
class StopError(Exception):
"""Raised from within a handler to indicate that no further
processing should happen. The provided ``text`` will be used as
the message reply (optional).
"""
def __init__(self, text=None):
self.text = text
def __str__(self):
return self.text
class FormatError(Exception):
"""Raised from within a handler to indicate a formatting
