Refactor events and test_events

manticore/utils/event.py

@@ -8,10 +8,10 @@
 
 
 class EventsGatherMetaclass(type):
-    '''
+    """
     Metaclass that is used for Eventful to gather events that classes declare to
     publish.
-    '''
+    """
     def __new__(cls, name, parents, d):
         eventful_sub = super(EventsGatherMetaclass, cls).__new__(cls, name, parents, d)
 
@@ -37,17 +37,17 @@ def __new__(cls, name, parents, d):
 
 
 class Eventful(object, metaclass=EventsGatherMetaclass):
-    '''
-        Abstract class for objects emitting and receiving events
-        An eventful object can:
-          - publish an event with arbitrary arguments to its subscribers
-          - let foreign objects subscribe their methods to events emitted here
-          - forward events to/from other eventful objects
-
-        Any time an Eventful object is unserialized:
-          - All previous subscriptions need to be resubscribed
-          - All objects that would previously receive forwarded events need to be reconnected
-    '''
+    """
+    Abstract class for objects emitting and receiving events
+    An eventful object can:
+      - publish an event with arbitrary arguments to its subscribers
+      - let foreign objects subscribe their methods to events emitted here
+      - forward events to/from other eventful objects
+
+    Any time an Eventful object is deserialized:
+      - All previous subscriptions need to be resubscribed
+      - All objects that would previously receive forwarded events need to be reconnected
+    """
 
     # Maps an Eventful subclass with a set of all the events it publishes.
     __all_events__ = dict()
@@ -60,9 +60,9 @@ class Eventful(object, metaclass=EventsGatherMetaclass):
 
     @classmethod
     def all_events(cls):
-        '''
+        """
         Return all events that all subclasses have so far registered to publish.
-        '''
+        """
         all_evts = set()
         for cls, evts in cls.__all_events__.items():
             all_evts.update(evts)
@@ -77,7 +77,7 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def __setstate__(self, state):
-        ''' It wont get serialized by design, user is responsible to reconnect'''
+        """It wont get serialized by design, user is responsible to reconnect"""
         self._signals = dict()
         self._forwards = WeakKeyDictionary()
         return True
@@ -139,22 +139,19 @@ def _publish_impl(self, _name, *args, **kwargs):
                 sink._publish_impl(_name, *args, **kwargs)
 
     def subscribe(self, name, method):
-        if not inspect.ismethod(method):
-            raise TypeError
+        assert inspect.ismethod(method), f'{method.__class__.__name__} is not a method'
         obj, callback = method.__self__, method.__func__
         bucket = self._get_signal_bucket(name)
         robj = ref(obj, self._unref)  # see unref() for explanation
         bucket.setdefault(robj, set()).add(callback)
 
     def forward_events_from(self, source, include_source=False):
-        if not isinstance(source, Eventful):
-            raise TypeError(f'{source.__class__.__name__} is not Eventful')
+        assert isinstance(source, Eventful), f'{source.__class__.__name__} is not Eventful'
         source.forward_events_to(self, include_source=include_source)
 
     def forward_events_to(self, sink, include_source=False):
-        ''' This forwards signal to sink '''
-        if not isinstance(sink, Eventful):
-            raise TypeError
+        """This forwards signal to sink"""
+        assert isinstance(sink, Eventful), f'{sink.__class__.__name__} is not Eventful'
         self._forwards[sink] = include_source
 
     def copy_eventful_state(self, new_object: 'Eventful'):

tests/test_events.py

@@ -1,15 +1,18 @@
-
 import unittest
 
 from manticore.utils.event import Eventful
 
+
 class A(Eventful):
-    _published_events = set(['eventA'])
+    _published_events = {'eventA'}
+
     def do_stuff(self):
-        self._publish("eventA",1, 'a')
+        self._publish("eventA", 1, 'a')
+
 
 class B(Eventful):
-    _published_events = set(['eventB'])
+    _published_events = {'eventB'}
+
     def __init__(self, child, **kwargs):
         super().__init__(**kwargs)
         self.child = child
@@ -19,19 +22,16 @@ def do_stuff(self):
         self._publish("eventB", 2, 'b')
 
 
-class C():
+class C:
     def __init__(self):
         self.received = []
+
     def callback(self, *args):
         self.received.append(args)
 
+
 class ManticoreDriver(unittest.TestCase):
     _multiprocess_can_split_ = True
-    def setUp(self):
-        self.state = {}
-
-    def tearDown(self):
-        pass
 
     def test_weak_references(self):
         a = A()
@@ -57,7 +57,6 @@ def test_weak_references(self):
         del b
         self.assertSequenceEqual([len(s) for s in (a._signals, a._forwards)], (0, 0))
 
-
     def test_basic(self):
         a = A()
         b = B(a)
@@ -71,5 +70,3 @@ def test_basic(self):
 
         b.do_stuff()
         self.assertSequenceEqual(c.received, [(1, 'a'), (2, 'b')])
-
-