EventController._dispatch_event() - Code Metrics - Inspection of "Removed QuantifiedCode." - SetBased/py-enarksh - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5e962d...d4663b )

by P.R.

created 2016-09-07 15:47 UTC

EventController._dispatch_event() B

↳ Parent: EventController

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	6.6

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	5
c	1
b	0
f	0
dl	0
loc	18
ccs	6
cts	10
cp	0.6
crap	6.6
rs	8.5454

"""
Enarksh

Copyright 2013-2016 Set Based IT Consultancy

Licence MIT
"""
import sys
import traceback

from enarksh.event.Event import Event
from enarksh.event.EventActor import EventActor


class EventController(EventActor):
    """
    A single threaded and a run-to-completion event controller. That is, each event is processed completely before any
    other event is processed. Hence, an event listener will run entirely before any other code runs (which can
    potentially modify the data the event listener invokes).

    Methods with name starting with 'internal_' MUST not be called from your application (only friend classes are
    allowed to call these methods).
    """

    # ------------------------------------------------------------------------------------------------------------------
    def __init__(self):
        """
        Object constructor.
        """
        Event.event_controller = self

        EventActor.__init__(self)

        self._events = dict()
        """
        All events in the current program.

        :type: dict[enarksh.event.Event.Event,dict[*,list[*]]]
        """

        self._listener_objects = dict()
        """

        :type: dict[*, set[enarksh.event.Event.Event]]
        """

        self._event_loop_start = Event(self)
        """
        Event that will be fired at the start of the event loop.

        :type: enarksh.event.Event.Event
        """

        self._event_loop_end = Event(self)
        """
        Event that will be fired at the end of the event loop.

        :type: enarksh.event.Event.Event
        """

        self._event_queue_empty = Event(self)
        """
        Event that will be fired when the event queue is empty.

        :type: enarksh.event.Event.Event
        """

        self.exit = False
        """
        If True the event loop terminates as soon as the event queue is emtpy. No event_queue_empty event will be fired.

        :type: bool
        """

        self._queue = []
        """
        The queue with events that have fired but have not been processed yet.

        :type: list[(enarksh.event.Event.Event,*)]
        """

    # ------------------------------------------------------------------------------------------------------------------
    @property
    def event_loop_end(self):
        """
        Returns the event that will be fired at the end of the event loop.

        :rtype: enarksh.event.Event.Event
        """
        return self._event_loop_end

    # ------------------------------------------------------------------------------------------------------------------
    @property
    def event_loop_start(self):
        """
        Returns the event that will be fired at the start of the event loop.

        :rtype: enarksh.event.Event.Event
        """
        return self._event_loop_start

    # ------------------------------------------------------------------------------------------------------------------
    @property
    def event_queue_empty(self):
        """
        Returns the event that will be fired when the event queue is empty.

        :rtype: enarksh.event.Event.Event
        """
        return self._event_queue_empty

    # ------------------------------------------------------------------------------------------------------------------
    def loop(self):
        """
        Start the event handler loop.

        The event handler loop terminates under each of the conditions below:
        * The event handler for 'event_queue_empty' completes without adding new events on the event queue.
        * Property exit has been set to True and the event queue is empty. Note: after property exit has been set to
          True event 'event_queue_empty' will not be fired any more.
        """
        self._dispatch_event(self._event_loop_start, None)

        if not self.exit and not self._queue:
            self._dispatch_event(self._event_queue_empty, None)

        while self._queue:
            event, event_data = self._queue.pop(0)

            self._dispatch_event(event, event_data)

            if not self._queue and not self.exit:
                self._dispatch_event(self._event_queue_empty, None)
                if not self._queue:
                    self.exit = True

        self._dispatch_event(self._event_loop_end, None)

    # ------------------------------------------------------------------------------------------------------------------
    def _dispatch_event(self, event, event_data):
        """
        Dispatches an event.

        :param enarksh.event.Event.Event event: The event to be dispatch.
        :param * event_data: Additional data supplied by the event source.
        """
        for listener_object, listeners in self._events[event.ref].items():
            for listener, listener_data in listeners:
                try:
                    if listener_object:
                        listener(listener_object(), event, event_data, listener_data)
                    else:
                        listener(event, event_data, listener_data)
                except Exception as exception:

                    # @todo Improve logging.
                    print(exception, file=sys.stderr)
                    traceback.print_exc(file=sys.stderr)

    # ------------------------------------------------------------------------------------------------------------------
    def internal_queue_event(self, event, event_data):
        """
        Puts an event that has fired on the event queue.

        Note: Do not use this method directly. Use enarksh.event.Event.Event.fire() instead.

        :param enarksh.event.Event.Event event: The event that has fired.
        :param * event_data: Additional data supplied by the event source.
        """
        self._queue.append((event, event_data))

    # ------------------------------------------------------------------------------------------------------------------
    def internal_unregister_event_ref(self, event_ref):
        """
        Removes an event as an event in the current program.

        Note: Do not use this method directly. Use enarksh.event.EventActor.EventActor.destroy() instead.

        :param enarksh.event.Event.Event event_ref: The event that must be removed.
        """
        if event_ref in self._events:
            for listener_object in self._events[event_ref].keys():
                events = self._listener_objects[listener_object]
                events.remove(event_ref)

                if not events:
                    del self._listener_objects[listener_object]

            del self._events[event_ref]

    # ------------------------------------------------------------------------------------------------------------------
    def internal_unregister_listener_object_ref(self, listener_object_ref):
        """
        Removes an object as a listener object (i.e. an object with one or more methods registered as event listeners).

        Note: Do not use this method directly.

        :param enarksh.event.Listener.Listener listener_object_ref: The listener object.
        """
        if listener_object_ref in self._listener_objects:
            # Remove the object from all events.
            for event in self._listener_objects[listener_object_ref]:
                del self._events[event][listener_object_ref]

            # Remove the object as listener object.
            del self._listener_objects[listener_object_ref]

    # ------------------------------------------------------------------------------------------------------------------
    def internal_register_event(self, event):
        """
        Registers an event as an event in the current program.

        Note: Do not use this method directly. This method is automatically called by
        enarksh.event.Event.Event#__init__()

        :param enarksh.event.Event.Event event: The event that must be registered.
        """
        self._events[event.ref] = dict()

    # ------------------------------------------------------------------------------------------------------------------
    def internal_register_listener(self, event, listener, listener_data=None):
        """
        Registers a callable as a listener for an event.

        Note: Do not use this method directly. Use enarksh.event.Event.Event.register_listener() instead.

        :param enarksh.event.Event.Event event: The event for which the listener needs to notified.
        :param callable listener: The callable that must be called when the event fires. If the callable is a class
                                  method it object must be an instance of enarksh.event.EventActor.EventActor.
        :param listener_data: Additional data supplied by the listener. This data will be passed to the listener when
                              the event fires.
        """
        if hasattr(listener, '__self__'):
            if not isinstance(listener.__self__, EventActor):
                raise ValueError('Only an event actor can be a listener, got {0}'.format(listener.__self__))
            listener_object = listener.__self__.ref
            listener = listener.__func__
        else:
            listener_object = None

        # Register the event and the listener.
        if listener_object not in self._events[event.ref]:
            self._events[event.ref][listener_object] = list()
        self._events[event.ref][listener_object].append((listener, listener_data))

        # Register the listener's object as a listener object.
        if listener_object not in self._listener_objects:
            self._listener_objects[listener_object] = set()
        self._listener_objects[listener_object].add(event.ref)

# ----------------------------------------------------------------------------------------------------------------------


1		"""
2		Enarksh
3
4		Copyright 2013-2016 Set Based IT Consultancy
5
6		Licence MIT
7		"""
8	1	import sys
9	1	import traceback
10
11	1	from enarksh.event.Event import Event
12	1	from enarksh.event.EventActor import EventActor
13
14
15	1	class EventController(EventActor):
16		"""
17		A single threaded and a run-to-completion event controller. That is, each event is processed completely before any
18		other event is processed. Hence, an event listener will run entirely before any other code runs (which can
19		potentially modify the data the event listener invokes).
20
21		Methods with name starting with 'internal_' MUST not be called from your application (only friend classes are
22		allowed to call these methods).
23		"""
24
25		# ------------------------------------------------------------------------------------------------------------------
26	1	def __init__(self):
27		"""
28		Object constructor.
29		"""
30	1	Event.event_controller = self
31
32	1	EventActor.__init__(self)
33
34	1	self._events = dict()
35		"""
36		All events in the current program.
37
38		:type: dict[enarksh.event.Event.Event,dict[,list[]]]
39		"""
40
41	1	self._listener_objects = dict()
42		"""
43
44		:type: dict[*, set[enarksh.event.Event.Event]]
45		"""
46
47	1	self._event_loop_start = Event(self)
48		"""
49		Event that will be fired at the start of the event loop.
50
51		:type: enarksh.event.Event.Event
52		"""
53
54	1	self._event_loop_end = Event(self)
55		"""
56		Event that will be fired at the end of the event loop.
57
58		:type: enarksh.event.Event.Event
59		"""
60
61	1	self._event_queue_empty = Event(self)
62		"""
63		Event that will be fired when the event queue is empty.
64
65		:type: enarksh.event.Event.Event
66		"""
67
68	1	self.exit = False
69		"""
70		If True the event loop terminates as soon as the event queue is emtpy. No event_queue_empty event will be fired.
71
72		:type: bool
73		"""
74
75	1	self._queue = []
76	1	"""
77		The queue with events that have fired but have not been processed yet.
78
79		:type: list[(enarksh.event.Event.Event,*)]
80		"""
81
82		# ------------------------------------------------------------------------------------------------------------------
83	1	@property
84		def event_loop_end(self):
85		"""
86		Returns the event that will be fired at the end of the event loop.
87
88		:rtype: enarksh.event.Event.Event
89		"""
90	1	return self._event_loop_end
91
92		# ------------------------------------------------------------------------------------------------------------------
93	1	@property
94		def event_loop_start(self):
95		"""
96		Returns the event that will be fired at the start of the event loop.
97
98		:rtype: enarksh.event.Event.Event
99		"""
100	1	return self._event_loop_start
101
102		# ------------------------------------------------------------------------------------------------------------------
103	1	@property
104		def event_queue_empty(self):
105		"""
106		Returns the event that will be fired when the event queue is empty.
107
108		:rtype: enarksh.event.Event.Event
109		"""
110	1	return self._event_queue_empty
111
112		# ------------------------------------------------------------------------------------------------------------------
113	1	def loop(self):
114		"""
115		Start the event handler loop.
116
117		The event handler loop terminates under each of the conditions below:
118		* The event handler for 'event_queue_empty' completes without adding new events on the event queue.
119		* Property exit has been set to True and the event queue is empty. Note: after property exit has been set to
120		True event 'event_queue_empty' will not be fired any more.
121		"""
122	1	self._dispatch_event(self._event_loop_start, None)
123
124	1	if not self.exit and not self._queue:
125	1	self._dispatch_event(self._event_queue_empty, None)
126
127	1	while self._queue:
128	1	event, event_data = self._queue.pop(0)
129
130	1	self._dispatch_event(event, event_data)
131
132	1	if not self._queue and not self.exit:
133	1	self._dispatch_event(self._event_queue_empty, None)
134	1	if not self._queue:
135	1	self.exit = True
136
137	1	self._dispatch_event(self._event_loop_end, None)
138
139		# ------------------------------------------------------------------------------------------------------------------
140	1	def _dispatch_event(self, event, event_data):
141		"""
142		Dispatches an event.
143
144		:param enarksh.event.Event.Event event: The event to be dispatch.
145		:param * event_data: Additional data supplied by the event source.
146		"""
147	1	for listener_object, listeners in self._events[event.ref].items():
148	1	for listener, listener_data in listeners:
149	1	try:
150	1	if listener_object:
151	1	listener(listener_object(), event, event_data, listener_data)
152		else:
153		listener(event, event_data, listener_data)
154		except Exception as exception:
		0 ignored issues – show Best Practice introduced 2016-07-28 16:54 UTC by Report Bug Copy Issue Report Catching very general exceptions such as `Exception` is usually not recommended. Generally, you would want to handle very specific errors in the exception handler. This ensure that you do not hide other types of errors which should be fixed. So, unless you specifically plan to handle any error, consider adding a more specific exception. Loading history...
155		# @todo Improve logging.
156		print(exception, file=sys.stderr)
157		traceback.print_exc(file=sys.stderr)
158
159		# ------------------------------------------------------------------------------------------------------------------
160	1	def internal_queue_event(self, event, event_data):
161		"""
162		Puts an event that has fired on the event queue.
163
164		Note: Do not use this method directly. Use enarksh.event.Event.Event.fire() instead.
165
166		:param enarksh.event.Event.Event event: The event that has fired.
167		:param * event_data: Additional data supplied by the event source.
168		"""
169	1	self._queue.append((event, event_data))
170
171		# ------------------------------------------------------------------------------------------------------------------
172	1	def internal_unregister_event_ref(self, event_ref):
173		"""
174		Removes an event as an event in the current program.
175
176		Note: Do not use this method directly. Use enarksh.event.EventActor.EventActor.destroy() instead.
177
178		:param enarksh.event.Event.Event event_ref: The event that must be removed.
179		"""
180	1	if event_ref in self._events:
181	1	for listener_object in self._events[event_ref].keys():
182	1	events = self._listener_objects[listener_object]
183	1	events.remove(event_ref)
184
185	1	if not events:
186	1	del self._listener_objects[listener_object]
187
188	1	del self._events[event_ref]
189
190		# ------------------------------------------------------------------------------------------------------------------
191	1	def internal_unregister_listener_object_ref(self, listener_object_ref):
192		"""
193		Removes an object as a listener object (i.e. an object with one or more methods registered as event listeners).
194
195		Note: Do not use this method directly.
196
197		:param enarksh.event.Listener.Listener listener_object_ref: The listener object.
198		"""
199	1	if listener_object_ref in self._listener_objects:
200		# Remove the object from all events.
201	1	for event in self._listener_objects[listener_object_ref]:
202	1	del self._events[event][listener_object_ref]
203
204		# Remove the object as listener object.
205	1	del self._listener_objects[listener_object_ref]
206
207		# ------------------------------------------------------------------------------------------------------------------
208	1	def internal_register_event(self, event):
209		"""
210		Registers an event as an event in the current program.
211
212		Note: Do not use this method directly. This method is automatically called by
213		enarksh.event.Event.Event#__init__()
214
215		:param enarksh.event.Event.Event event: The event that must be registered.
216		"""
217	1	self._events[event.ref] = dict()
218
219		# ------------------------------------------------------------------------------------------------------------------
220	1	def internal_register_listener(self, event, listener, listener_data=None):
221		"""
222		Registers a callable as a listener for an event.
223
224		Note: Do not use this method directly. Use enarksh.event.Event.Event.register_listener() instead.
225
226		:param enarksh.event.Event.Event event: The event for which the listener needs to notified.
227		:param callable listener: The callable that must be called when the event fires. If the callable is a class
228		method it object must be an instance of enarksh.event.EventActor.EventActor.
229		:param listener_data: Additional data supplied by the listener. This data will be passed to the listener when
230		the event fires.
231		"""
232	1	if hasattr(listener, '__self__'):
233	1	if not isinstance(listener.__self__, EventActor):
234		raise ValueError('Only an event actor can be a listener, got {0}'.format(listener.__self__))
235	1	listener_object = listener.__self__.ref
236	1	listener = listener.__func__
237		else:
238		listener_object = None
239
240		# Register the event and the listener.
241	1	if listener_object not in self._events[event.ref]:
242	1	self._events[event.ref][listener_object] = list()
243	1	self._events[event.ref][listener_object].append((listener, listener_data))
244
245		# Register the listener's object as a listener object.
246	1	if listener_object not in self._listener_objects:
247	1	self._listener_objects[listener_object] = set()
248	1	self._listener_objects[listener_object].add(event.ref)
249
250		# ----------------------------------------------------------------------------------------------------------------------
251

SetBased / py-enarksh

GitHub Access Token became invalid

Push — master ( 5e962d...d4663b )

EventController._dispatch_event() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like