GwBasePattern.__init__() - Code Metrics - Inspection of "Added plugin dependency logic" - useblocks/groundwork - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8ab379...373224 )

by Daniel

created 2016-11-18 13:11 UTC

GwBasePattern.init() D

↳ Parent: GwBasePattern

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
cc	8
c	2
b	1
f	0
dl	0
loc	47
rs	4.3478

"""
    gw_base_pattern provides all basic classes and functions, which are needed by any kind of groundwork plugin or
    pattern.

    It mostly cares about the correct activation and deactivation. Including sending signals to inform
    other patterns or plugins about status changes of a plugin.

"""
import logging
from groundwork.patterns.exceptions import PluginAttributeMissing, PluginActivateMissing, PluginDeactivateMissing, \
    PluginDependencyLoop


class GwBasePattern(object):
    """
    Base pattern class for all plugins and patterns.

    Usage::

        from groundwork.patterns import GwBasePattern

        class MyPlugin(GwBasePattern):
            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)

            def activate():
                self.signals.register("MySignal", "My description about signal)

            def deactivate():
                self.signals.unregister("MySignal")

    :param app: groundwork application object, for which the plugin shall be initialised.
    :type app: :class:`groundwork.App`.
    :param name: Unique name. Normally set by plugin.
    """
    def __init__(self, app, *args, name=None, **kwargs):
        #: groundwork application instance. Access it inside a plugin via ``self.app``.
        self.app = app

        # There must be a name for this plugin. Otherwise it is not detectable and manageable on application level
        if not hasattr(self, "name") and name is None:
            raise PluginAttributeMissing("Name not set for plugin")
        elif not hasattr(self, "name") and name is not None:
            # Set the given name, if the plugin itself does not have set one
            self.name = name

        # Be sure we have a set version number. Can be overwritten by the plugin itself.
        if not hasattr(self, "version"):
            self.version = "0.0.1"

        # Let's be sure active is false, even if a child class set something different
        if not hasattr(self, "active"):
            self.active = False

        # Even if this plugin has no dependencies to other plugins, we should set an empty tuple.
        if not hasattr(self, "needed_plugins"):
            #: Variable for storing dependencies to other plugins.
            #: Tuple must contains needed plugin names.
            #: needed_plugins = ("MyPlugin", "MyPlugin2)
            self.needed_plugins = ()

        #: A logger, especially created for this plugin. Usage inside a plugin: ``self.log.warn("WARNING!!")``.
        #:
        #: The logger name is the same as the plugin name. Therefor it is possible to configure the application logging
        #: to show log messages of a specif plugin only. See :ref:`plugin_logging`
        self.log = logging.getLogger(self.name)

        #: Instance of :class:`.SignalsPlugin`.
        #: Provides functions to register and manage signals and retrievers.
        #:
        #: All action takes place in the context of this plugin. For instance a ``self.signals.get()`` will return
        #: signals of this plugin only. To get all signals of an application, please use ``self.app.signals.get()``.
        self.signals = SignalsPlugin(self)

        # This is used as flag for the pluginManager to be sure, that an initiated class has called the __init__()
        # routine of GwPluginPatter
        self._plugin_base_initialised = True

        # Let's tell the pluginManager that this plugin got initialised, so that it gets tracked on app level.
        # This is needed if this class gets initiated by hand and the function self.app.plugins._load() was not used
        # for doing this job.
        self.app.plugins._register_initialisation(self)

    # def __getattribute__(self, name):
    def __getattribute__(self, name):
        """
        Catches all calls on class attributes, but cares only for activate() and deactivate().

        If the plugin gets activated or deactivated, the base class can perform extra work.
        So there is no need for a plugin developer to call something like super().activate() for
        his/her plugin. This gets done automatically.
        """

        attr = object.__getattribute__(self, name)
        if hasattr(attr, '__call__'):
            if hasattr(attr, "__name__"):
                if attr.__name__ == "activate":
                    def newfunc(*args, **kwargs):
                        self._pre_activate_injection()
                        result = attr(*args, **kwargs)
                        self._post_activate_injection()
                        return result
                    return newfunc
                elif attr.__name__ == "deactivate":
                    def newfunc(*args, **kwargs):
                        self._pre_deactivate_injection()
                        result = attr(*args, **kwargs)
                        self._post_deactivate_injection()
                        return result
                    return newfunc

        return attr

    def activate(self):
        """
        Must be overwritten by the plugin class itself.
        """
        self.log.warn("No activation routine in Plugin defined. Define self.activate() in plugin %s" % self.name)
        raise PluginActivateMissing("plugin must provide an activation routine by itself.")

    def deactivate(self):
        """
        Must be overwritten by the plugin class itself.
        """
        self.log.warn("No activation routine in Plugin defined. Define self.deactivate() in plugin %s" % self.name)
        raise PluginDeactivateMissing("plugin must provide an deactivation routine by itself.")

    def _pre_activate_injection(self):
        """
        Injects functions before the activation routine of child classes gets called
        """
        # Let's be sure that this plugins class is registered and available on application level under
        # application.plugins.classes. This allows to reuse this class for *new* plugins.
        if not self.app.plugins.classes.exist(self.__class__.__name__):
            self.app.plugins.classes.register([self.__class__])

        self._load_needed_plugins()

        self.app.signals.send("plugin_activate_pre", self)

    def _post_activate_injection(self):
        """
        Injects functions after the activation routine of child classes got called
        :return: None
        """
        self.active = True
        self.app.signals.send("plugin_activate_post", self)

    def _pre_deactivate_injection(self):
        """
        Injects functions before the deactivation routine of child classes gets called
        :return: None
        """
        self.app.signals.send("plugin_deactivate_pre", self)

    def _post_deactivate_injection(self):
        """
        Injects functions after the deactivation routine of child classes got called
        :return: None
        """
        # Lets be sure that active is really set to false.
        self.active = False
        self.app.signals.send("plugin_deactivate_post", self)
        # After all receivers are handled. We start to clean up signals and receivers of this plugin
        # Attention: This signal clean must not be called via a signal (like in other patterns),
        # because the call order of receivers is not clear and a signal/receiver clean up would prohibit the call
        # of all "later" receivers.
        self.signals.deactivate_plugin_signals()

    def _load_needed_plugins(self):
        """
        Checks if this plugins needs other plugins to work and tries to activate them
        :return: True, if all needed plugins are or got activated. Otherwise False
        """
        global plugin_recursive_store
        if "plugin_recursive_store" not in globals():
            plugin_recursive_store = []

        if self.name in plugin_recursive_store:
            self.log.warning("Plugin dependency loop detected: %s already checked and dependencies got activated" %
                             self.name)
            if self.app.strict:
                raise PluginDependencyLoop("Plugin dependency loop detected: %s already checked and dependencies "
                                           "got activated" % self.name)
            return False
        else:
            plugin_recursive_store.append(self.name)

        if not hasattr(self, "needed_plugins"):
            pass
        elif not isinstance(self.needed_plugins, tuple) or isinstance(self.needed_plugins, list):
            raise TypeError("needed_plugins must be a tuple or a list")
        elif len(self.needed_plugins) > 0:
            try:
                for needed_plugin in self.needed_plugins:
                    if not isinstance(needed_plugin, str):
                        raise TypeError("Plugin name must be a string, got %s" % type(needed_plugin).__name__)
                    # Check, if a plugin with this name got already activated
                    plugin = self.app.plugins.get(needed_plugin)
                    if plugin is not None and not plugin.active:
                        plugin.activate()
                    # If not, check if a plugin_class with this name is available and activate it
                    plugin_class = self.app.plugins.classes.get(needed_plugin)
                    if plugin_class is not None:
                        plugin_class(self.app, needed_plugin)
            except Exception:
                plugin_recursive_store.remove(self.name)
                return False

        plugin_recursive_store.remove(self.name)
        return True


class SignalsPlugin:
    """
    Signal and Receiver management class on plugin level.
    This class gets initiated once per plugin.

    Mostly delegates function calls to the :class:`groundwork.signals.SignalListApplication` instance on application
    level.

    :param plugin: The plugin, which wants to use signals
    :type plugin: GwBasePattern
    """

    def __init__(self, plugin):
        self._plugin = plugin
        self.__app = plugin.app
        self.__log = plugin.log
        self.__log.info("Plugin messages initialised")

    def deactivate_plugin_signals(self):
        receivers = self.get_receiver()
        for receiver in receivers.keys():
            self.disconnect(receiver)

        signals = self.get()
        for signal in signals:
            self.unregister(signal)

    def register(self, signal, description):
        """
        Registers a new signal.
        Only registered signals are allowed to be send.

        :param signal: Unique name of the signal
        :param description: Description of the reason or use case, why this signal is needed.
                            Used for documentation.
        """
        return self.__app.signals.register(signal, self._plugin, description)

    def unregister(self, signal):
        return self.__app.signals.unregister(signal)

    def connect(self, receiver, signal, function, description, sender=None):
        """
        Connect a receiver to a signal

        :param receiver: Name of the receiver
        :type receiver: str
        :param signal: Name of the signal. Must already be registered!
        :type signal: str
        :param function: Callable functions, which shall be executed, of signal is send.
        :param description: Description of the reason or use case, why this connection is needed.
                            Used for documentation.
        """
        return self.__app.signals.connect(receiver, signal, function, self._plugin, description, sender)

    def disconnect(self, receiver):
        """
        Disconnect a receiver from a signal.
        Receiver must exist, otherwise an exception is thrown.

        :param receiver: Name of the receiver
        """
        return self.__app.signals.disconnect(receiver)

    def send(self, signal, **kwargs):
        """
        Sends a signal for the given plugin.

        :param signal: Name of the signal
        :type signal: str
        """
        return self.__app.signals.send(signal, plugin=self._plugin, **kwargs)

    def get(self, signal=None):
        """
        Returns a single signal or a dictionary of signals for this plugin.
        """
        return self.__app.signals.get(signal, self._plugin)

    def get_receiver(self, receiver=None):
        """
        Returns a single receiver or a dictionary of receivers for this plugin.
        """
        return self.__app.signals.get_receiver(receiver, self._plugin)


1			"""
2			gw_base_pattern provides all basic classes and functions, which are needed by any kind of groundwork plugin or
3			pattern.
4
5			It mostly cares about the correct activation and deactivation. Including sending signals to inform
6			other patterns or plugins about status changes of a plugin.
7
8			"""
9			import logging
10			from groundwork.patterns.exceptions import PluginAttributeMissing, PluginActivateMissing, PluginDeactivateMissing, \
11			PluginDependencyLoop
12
13
14			class GwBasePattern(object):
15			"""
16			Base pattern class for all plugins and patterns.
17
18			Usage::
19
20			from groundwork.patterns import GwBasePattern
21
22			class MyPlugin(GwBasePattern):
23			def __init__(self, args, *kwargs):
24			super().__init__(args, *kwargs)
25
26			def activate():
27			self.signals.register("MySignal", "My description about signal)
28
29			def deactivate():
30			self.signals.unregister("MySignal")
31
32			:param app: groundwork application object, for which the plugin shall be initialised.
33			:type app: :class:`groundwork.App`.
34			:param name: Unique name. Normally set by plugin.
35			"""
36			def __init__(self, app, args, name=None, *kwargs):
37			#: groundwork application instance. Access it inside a plugin via ``self.app``.
38			self.app = app
39
40			# There must be a name for this plugin. Otherwise it is not detectable and manageable on application level
41			if not hasattr(self, "name") and name is None:
42			raise PluginAttributeMissing("Name not set for plugin")
43			elif not hasattr(self, "name") and name is not None:
44			# Set the given name, if the plugin itself does not have set one
45			self.name = name
46
47			# Be sure we have a set version number. Can be overwritten by the plugin itself.
48			if not hasattr(self, "version"):
49			self.version = "0.0.1"
50
51			# Let's be sure active is false, even if a child class set something different
52			if not hasattr(self, "active"):
53			self.active = False
54
55			# Even if this plugin has no dependencies to other plugins, we should set an empty tuple.
56			if not hasattr(self, "needed_plugins"):
57			#: Variable for storing dependencies to other plugins.
58			#: Tuple must contains needed plugin names.
59			#: needed_plugins = ("MyPlugin", "MyPlugin2)
60			self.needed_plugins = ()
61
62			#: A logger, especially created for this plugin. Usage inside a plugin: ``self.log.warn("WARNING!!")``.
63			#:
64			#: The logger name is the same as the plugin name. Therefor it is possible to configure the application logging
65			#: to show log messages of a specif plugin only. See :ref:`plugin_logging`
66			self.log = logging.getLogger(self.name)
67
68			#: Instance of :class:`.SignalsPlugin`.
69			#: Provides functions to register and manage signals and retrievers.
70			#:
71			#: All action takes place in the context of this plugin. For instance a ``self.signals.get()`` will return
72			#: signals of this plugin only. To get all signals of an application, please use ``self.app.signals.get()``.
73			self.signals = SignalsPlugin(self)
74
75			# This is used as flag for the pluginManager to be sure, that an initiated class has called the __init__()
76			# routine of GwPluginPatter
77			self._plugin_base_initialised = True
78
79			# Let's tell the pluginManager that this plugin got initialised, so that it gets tracked on app level.
80			# This is needed if this class gets initiated by hand and the function self.app.plugins._load() was not used
81			# for doing this job.
82			self.app.plugins._register_initialisation(self)
83
84			# def __getattribute__(self, name):
85			def __getattribute__(self, name):
86			"""
87			Catches all calls on class attributes, but cares only for activate() and deactivate().
88
89			If the plugin gets activated or deactivated, the base class can perform extra work.
90			So there is no need for a plugin developer to call something like super().activate() for
91			his/her plugin. This gets done automatically.
92			"""
93
94			attr = object.__getattribute__(self, name)
95			if hasattr(attr, '__call__'):
96			if hasattr(attr, "__name__"):
97			if attr.__name__ == "activate":
98			def newfunc(args, *kwargs):
99			self._pre_activate_injection()
100			result = attr(args, *kwargs)
101			self._post_activate_injection()
102			return result
103			return newfunc
104			elif attr.__name__ == "deactivate":
105			def newfunc(args, *kwargs):
106			self._pre_deactivate_injection()
107			result = attr(args, *kwargs)
108			self._post_deactivate_injection()
109			return result
110			return newfunc
111
112			return attr
113
114			def activate(self):
115			"""
116			Must be overwritten by the plugin class itself.
117			"""
118			self.log.warn("No activation routine in Plugin defined. Define self.activate() in plugin %s" % self.name)
119			raise PluginActivateMissing("plugin must provide an activation routine by itself.")
120
121			def deactivate(self):
122			"""
123			Must be overwritten by the plugin class itself.
124			"""
125			self.log.warn("No activation routine in Plugin defined. Define self.deactivate() in plugin %s" % self.name)
126			raise PluginDeactivateMissing("plugin must provide an deactivation routine by itself.")
127
128			def _pre_activate_injection(self):
129			"""
130			Injects functions before the activation routine of child classes gets called
131			"""
132			# Let's be sure that this plugins class is registered and available on application level under
133			# application.plugins.classes. This allows to reuse this class for new plugins.
134			if not self.app.plugins.classes.exist(self.__class__.__name__):
135			self.app.plugins.classes.register([self.__class__])
136
137			self._load_needed_plugins()
138
139			self.app.signals.send("plugin_activate_pre", self)
140
141			def _post_activate_injection(self):
142			"""
143			Injects functions after the activation routine of child classes got called
144			:return: None
145			"""
146			self.active = True
147			self.app.signals.send("plugin_activate_post", self)
148
149			def _pre_deactivate_injection(self):
150			"""
151			Injects functions before the deactivation routine of child classes gets called
152			:return: None
153			"""
154			self.app.signals.send("plugin_deactivate_pre", self)
155
156			def _post_deactivate_injection(self):
157			"""
158			Injects functions after the deactivation routine of child classes got called
159			:return: None
160			"""
161			# Lets be sure that active is really set to false.
162			self.active = False
163			self.app.signals.send("plugin_deactivate_post", self)
164			# After all receivers are handled. We start to clean up signals and receivers of this plugin
165			# Attention: This signal clean must not be called via a signal (like in other patterns),
166			# because the call order of receivers is not clear and a signal/receiver clean up would prohibit the call
167			# of all "later" receivers.
168			self.signals.deactivate_plugin_signals()
169
170			def _load_needed_plugins(self):
171			"""
172			Checks if this plugins needs other plugins to work and tries to activate them
173			:return: True, if all needed plugins are or got activated. Otherwise False
174			"""
175			global plugin_recursive_store
176			if "plugin_recursive_store" not in globals():
177			plugin_recursive_store = []
178
179			if self.name in plugin_recursive_store:
180			self.log.warning("Plugin dependency loop detected: %s already checked and dependencies got activated" %
181			self.name)
182			if self.app.strict:
183			raise PluginDependencyLoop("Plugin dependency loop detected: %s already checked and dependencies "
184			"got activated" % self.name)
185			return False
186			else:
187			plugin_recursive_store.append(self.name)
188
189			if not hasattr(self, "needed_plugins"):
190			pass
191			elif not isinstance(self.needed_plugins, tuple) or isinstance(self.needed_plugins, list):
192			raise TypeError("needed_plugins must be a tuple or a list")
193			elif len(self.needed_plugins) > 0:
194			try:
195			for needed_plugin in self.needed_plugins:
196			if not isinstance(needed_plugin, str):
197			raise TypeError("Plugin name must be a string, got %s" % type(needed_plugin).__name__)
198			# Check, if a plugin with this name got already activated
199			plugin = self.app.plugins.get(needed_plugin)
200			if plugin is not None and not plugin.active:
201			plugin.activate()
202			# If not, check if a plugin_class with this name is available and activate it
203			plugin_class = self.app.plugins.classes.get(needed_plugin)
204			if plugin_class is not None:
205			plugin_class(self.app, needed_plugin)
206			except Exception:
207			plugin_recursive_store.remove(self.name)
208			return False
209
210			plugin_recursive_store.remove(self.name)
211			return True
212
213
214			class SignalsPlugin:
215			"""
216			Signal and Receiver management class on plugin level.
217			This class gets initiated once per plugin.
218
219			Mostly delegates function calls to the :class:`groundwork.signals.SignalListApplication` instance on application
220			level.
221
222			:param plugin: The plugin, which wants to use signals
223			:type plugin: GwBasePattern
224			"""
225
226			def __init__(self, plugin):
227			self._plugin = plugin
228			self.__app = plugin.app
229			self.__log = plugin.log
230			self.__log.info("Plugin messages initialised")
231
232			def deactivate_plugin_signals(self):
233			receivers = self.get_receiver()
234			for receiver in receivers.keys():
235			self.disconnect(receiver)
236
237			signals = self.get()
238			for signal in signals:
239			self.unregister(signal)
240
241			def register(self, signal, description):
242			"""
243			Registers a new signal.
244			Only registered signals are allowed to be send.
245
246			:param signal: Unique name of the signal
247			:param description: Description of the reason or use case, why this signal is needed.
248			Used for documentation.
249			"""
250			return self.__app.signals.register(signal, self._plugin, description)
251
252			def unregister(self, signal):
253			return self.__app.signals.unregister(signal)
254
255			def connect(self, receiver, signal, function, description, sender=None):
256			"""
257			Connect a receiver to a signal
258
259			:param receiver: Name of the receiver
260			:type receiver: str
261			:param signal: Name of the signal. Must already be registered!
262			:type signal: str
263			:param function: Callable functions, which shall be executed, of signal is send.
264			:param description: Description of the reason or use case, why this connection is needed.
265			Used for documentation.
266			"""
267			return self.__app.signals.connect(receiver, signal, function, self._plugin, description, sender)
268
269			def disconnect(self, receiver):
270			"""
271			Disconnect a receiver from a signal.
272			Receiver must exist, otherwise an exception is thrown.
273
274			:param receiver: Name of the receiver
275			"""
276			return self.__app.signals.disconnect(receiver)
277
278			def send(self, signal, **kwargs):
279			"""
280			Sends a signal for the given plugin.
281
282			:param signal: Name of the signal
283			:type signal: str
284			"""
285			return self.__app.signals.send(signal, plugin=self._plugin, **kwargs)
286
287			def get(self, signal=None):
288			"""
289			Returns a single signal or a dictionary of signals for this plugin.
290			"""
291			return self.__app.signals.get(signal, self._plugin)
292
293			def get_receiver(self, receiver=None):
294			"""
295			Returns a single receiver or a dictionary of receivers for this plugin.
296			"""
297			return self.__app.signals.get_receiver(receiver, self._plugin)
298

useblocks / groundwork

Push — master ( 8ab379...373224 )

GwBasePattern.__init__() D

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

GwBasePattern.init() D