Fixed signals implementation

tests were breaking

Fixed signals implementation
tests were breaking
Sergio Oliveira
1 parent c30d7a00
Showing 5 changed files with 38 additions and 30 deletions Show diff stats
colab/__init__.py
colab/plugins/__init__.py
colab/plugins/apps.py
colab/plugins/utils/apps.py
colab/plugins/utils/signals.py
 from __future__ import absolute_import
+from . import plugins
+
 # This will make sure the app is always imported when
 # Django starts so that shared_task will use this app.
 from .celery import app as celery_app  # noqa
+
@@ -0,0 +1,2 @@
+
+default_app_config = 'colab.plugins.apps.PluginAppConfig'
@@ -0,0 +1,12 @@
+
+from django.apps import AppConfig
+
+from .utils.signals import connect_signal, register_signal
+
+
+class PluginAppConfig(AppConfig):
+    name = 'colab.plugins'
+
+    def ready(self):
+        register_signal()
+        connect_signal()
-import importlib
-import inspect
 from django.apps import AppConfig
-from colab.plugins.utils.signals import AbstractSignal
 class ColabProxiedAppConfig(AppConfig):
     colab_proxied_app = True
-    def __init__(self, app_name, app_module):
-        super(ColabProxiedAppConfig, self).__init__(app_name, app_module)
-        self._import_signals(app_name)
-        self.signals.register_signal()
+    def register_signals(self):
+        pass
-    def _import_signals(self, app_name):
-        self.module_path = app_name + '.signals'
-        self.module = importlib.import_module(self.module_path)
-
-        for module_item_name in dir(self.module):
-            module_item = getattr(self.module, module_item_name)
-            if not inspect.isclass(module_item):
-                continue
-            if issubclass(module_item, AbstractSignal):
-                if module_item != AbstractSignal:
-                    self.signals = module_item()
-                    break
-
-    def ready(self):
-        self.signals.connect_signal()
+    def connect_signals(self):
+        pass
-from abc import abstractmethod
+from django.apps import apps
-class AbstractSignal(object):
+def _init_signals(method_name):
+    for app in apps.get_app_configs():
+        # Try to get the method with `method_name`.
+        #   If it exists call it using `app` as the first parameter.
+        #   This is required because methods take `self` as first
+        #   parameter and as we are calling it as a function python
+        #   won't send it explicitly.
+        # If the method doesn't exist we return a dummy function that
+        #   won't do anything.
+        getattr(app, method_name, lambda x: None)(app)
-    @abstractmethod
-    def register_signal(self):
-        raise NotImplementedError
-    @abstractmethod
-    def connect_signal(self):
-        raise NotImplementedError
+def register_signal():
+    _init_signals('register_signal')
+
+
+def connect_signal():
+    _init_signals('connect_signal')
1	from __future__ import absolute_import	1	from __future__ import absolute_import
2		2
		3	+from . import plugins
		4	+
3	# This will make sure the app is always imported when	5	# This will make sure the app is always imported when
4	# Django starts so that shared_task will use this app.	6	# Django starts so that shared_task will use this app.
5	from .celery import app as celery_app # noqa	7	from .celery import app as celery_app # noqa
		8	+
@@ -0,0 +1,2 @@		@@ -0,0 +1,2 @@
	1	+
	2	+default_app_config = 'colab.plugins.apps.PluginAppConfig'
@@ -0,0 +1,12 @@		@@ -0,0 +1,12 @@
	1	+
	2	+from django.apps import AppConfig
	3	+
	4	+from .utils.signals import connect_signal, register_signal
	5	+
	6	+
	7	+class PluginAppConfig(AppConfig):
	8	+ name = 'colab.plugins'
	9	+
	10	+ def ready(self):
	11	+ register_signal()
	12	+ connect_signal()
1	-import importlib
2	-import inspect
3		1
4	from django.apps import AppConfig	2	from django.apps import AppConfig
5	-from colab.plugins.utils.signals import AbstractSignal
6		3
7		4
8	class ColabProxiedAppConfig(AppConfig):	5	class ColabProxiedAppConfig(AppConfig):
9	colab_proxied_app = True	6	colab_proxied_app = True
10		7
11	- def __init__(self, app_name, app_module):
12	- super(ColabProxiedAppConfig, self).__init__(app_name, app_module)
13	- self._import_signals(app_name)
14	- self.signals.register_signal()	8	+ def register_signals(self):
		9	+ pass
15		10
16	- def _import_signals(self, app_name):
17	- self.module_path = app_name + '.signals'
18	- self.module = importlib.import_module(self.module_path)
19	-
20	- for module_item_name in dir(self.module):
21	- module_item = getattr(self.module, module_item_name)
22	- if not inspect.isclass(module_item):
23	- continue
24	- if issubclass(module_item, AbstractSignal):
25	- if module_item != AbstractSignal:
26	- self.signals = module_item()
27	- break
28	-
29	- def ready(self):
30	- self.signals.connect_signal()	11	+ def connect_signals(self):
		12	+ pass
1		1
2	-from abc import abstractmethod	2	+from django.apps import apps
3		3
4		4
5	-class AbstractSignal(object):	5	+def _init_signals(method_name):
		6	+ for app in apps.get_app_configs():
		7	+ # Try to get the method with `method_name`.
		8	+ # If it exists call it using `app` as the first parameter.
		9	+ # This is required because methods take `self` as first
		10	+ # parameter and as we are calling it as a function python
		11	+ # won't send it explicitly.
		12	+ # If the method doesn't exist we return a dummy function that
		13	+ # won't do anything.
		14	+ getattr(app, method_name, lambda x: None)(app)
6		15
7	- @abstractmethod
8	- def register_signal(self):
9	- raise NotImplementedError
10		16
11	- @abstractmethod
12	- def connect_signal(self):
13	- raise NotImplementedError	17	+def register_signal():
		18	+ _init_signals('register_signal')
		19	+
		20	+
		21	+def connect_signal():
		22	+ _init_signals('connect_signal')