Move event level filtering to listeners.

Previously you specified the events sent to a listener on initial
registration. It made more sense to move this to a listener.accepts
function because 9/10 times the events will always be the same and
that edge case can be covered by configuring the Listener before
registration.

Author: GraylinKim

sc2reader/factories.py

@@ -107,7 +107,7 @@ def reset(self):
         self.options = utils.AttributeDict(self.default_options)
         self.registered_readers = defaultdict(list)
         self.registered_datapacks = list()
-        self.registered_listeners = defaultdict(list)
+        self.registered_listeners = list()
 
     def load_resources(self, resources, resource_loader, options=None, **new_options):
         """
@@ -286,42 +286,30 @@ def get_datapack(self, replay):
         return None
 
     def get_listeners(self, replay):
-        listeners = defaultdict(list)
-        for event_class in self.registered_listeners.keys():
-            for callback, listener in self.registered_listeners[event_class]:
-                if callback(replay):
-                    listeners[event_class].append(listener)
+        listeners = list()
+        for callback, listener in self.registered_listeners:
+            if callback(replay):
+                listeners.append(listener)
         return listeners
 
 
-    def register_listener(self, events, listener, filterfunc=lambda r: True):
+    def register_listener(self, listener, filterfunc=lambda r: True):
         """
         Allows you to specify event listeners for adding new features to the
         :class:`Replay` objects on :meth:`~Replay.play`. sc2reader comes with a
         small collection of :class:`Listener` classes that you can apply to your
-        replays as needed.
-
-        Events are sent to listeners in registration order as they come up. By
-        specifying a parent class you can register a listener to a set of events
-        at once instead of listing them out individually. See the tutorials for
-        more information.
-
-        :param events: A list of event classes you want sent to this listener.
-            Registration to a single event can be done by specifying a single
-            event class instead of a list. An isinstance() check is used so
-            you can catch sets of classes at once by supplying a parent class.
+        replays as needed. Events are sent to listeners in registration order as
+        they come up. See the tutorials for more information.
 
         :param listener: The :class:`Listener` object you want events sent to.
+            You must pass an instanciated object NOT a class. This gives you an
+            opportunity to configure the listener before registration.
 
         :param filterfunc: A function that accepts a partially loaded
             :class:`Replay` object as an argument and returns true if the
             reader should be used on this replay.
         """
-        try:
-            for event in events:
-                self.registered_listeners[event].append((filterfunc, listener))
-        except TypeError:
-            self.registered_listeners[events].append((filterfunc, listener))
+        self.registered_listeners.append((filterfunc, listener))
 
     def register_reader(self, data_file, reader, filterfunc=lambda r: True):
         """

sc2reader/listeners/apm.py

@@ -1,5 +1,6 @@
 from __future__ import absolute_import
 
+from sc2reader.events import GameEvent
 from sc2reader.listeners.utils import ListenerBase
 
 from collections import defaultdict
@@ -12,12 +13,14 @@ def setup(self, replay):
             player.apm = defaultdict(int)
             player.avg_apm = 0
 
+    def accepts(self, event):
+        return isinstance(sc2reader.events.GameEvent) and event.is_local and event.is_player_action
+
     def __call__(self, event, replay):
-        if event.is_local and event.is_player_action:
-            player = event.player
-            if not player.is_observer:
-                # Count up the APS, APM
-                minute =  event.second/60.0
-                player.aps[event.second] += 1
-                player.apm[int(minutes)] += 1
-                player.avg_apm = sum(player.apm.values())/minutes
+        player = event.player
+        if not player.is_observer:
+            # Count up the APS, APM
+            minute =  event.second/60.0
+            player.aps[event.second] += 1
+            player.apm[int(minutes)] += 1
+            player.avg_apm = sum(player.apm.values())/minutes

sc2reader/listeners/selection.py

@@ -72,13 +72,10 @@ def setup(self, replay):
         for player in replay.people:
             player.selections = GameState(PlayerSelection())
 
-    def __call__(self, event, replay):
-        # TODO: The whole register_listener thing is really clunky
-        #   right now. In some cases, listeners already know what
-        #   they want to listen to.
-        if not (isinstance(event, events.SelectionEvent) or isinstance(event, events.HotkeyEvent)):
-            return
+    def accepts(self, event):
+        return isinstance(event, events.SelectionEvent) or isinstance(event, events.HotkeyEvent)
 
+    def __call__(self, event, replay):
         if replay.opt.debug:
             self.logger.debug("Event bytes: "+event.bytes.encode("hex"))
 

sc2reader/listeners/utils.py

@@ -2,4 +2,7 @@
 
 class ListenerBase(object):
     def __init__(self):
-        self.logger = log_utils.get_logger(self.__class__)
+        self.logger = log_utils.get_logger(self.__class__)
+
+    def accepts(self, event):
+        return true

sc2reader/resources.py

@@ -355,15 +355,13 @@ def load_events(self, datapack=None):
     def start(self):
         self.stopped = False
 
-        for event_type, listeners in self.listeners.iteritems():
-            for listener in listeners:
-                listener.setup(self)
+        for listener in self.listeners:
+            listener.setup(self)
 
         for event in self.events:
-            for event_type, listeners in self.listeners.iteritems():
-                if isinstance(event, event_type):
-                    for listener in listeners:
-                        listener(event, self)
+            for listener in self.listeners:
+                if listener.accepts(event):
+                    listener(event, self)
 
 
 class Map(Resource):