Change the Reader call interface to use __call__.

Also apply a general cleanup of the processor code.

Author: GraylinKim

sc2reader/__init__.py

@@ -33,20 +33,20 @@ def read(self, location):
             tolist = lambda x: [x] if isinstance(x,Replay) else x
             return sum(map(tolist,(read(x) for x in os.listdir(location))),[])
 
-        else:
-            with open(location) as replay_file:
-                replay = Replay(replay_file,**self.options.copy())
-                archive = mpyq.MPQArchive(location,listfile=False)
+        with open(location) as replay_file:
+            replay = Replay(replay_file,**self.options.copy())
+            archive = mpyq.MPQArchive(location,listfile=False)
 
-                for file in self.files:
-                    buffer = ReplayBuffer(archive.read_file(file))
-                    READERS[replay.build][file].read(buffer,replay)
+            for file in self.files:
+                buffer = ReplayBuffer(archive.read_file(file))
+                read = config.readers[replay.build][file]
+                read(buffer,replay)
 
-                #Handle user processors after internal processors
-                for process in self.processors+self.options.processors:
-                    replay = process(replay)
+            #Handle user processors after internal processors
+            for process in self.processors+self.options.processors:
+                replay = process(replay)
 
-                return replay
+            return replay
 
     def configure(self,**options):
         self.options.update(options)

sc2reader/config.py

@@ -77,4 +77,4 @@ def __getitem__(self,key):
         except KeyError:
             return self.set3
 
-READERS = ReaderMap()
+readers = ReaderMap()

sc2reader/readers.py

@@ -8,23 +8,21 @@
 #################################################
 
 class InitDataReader(object):
-    def read(self, buffer, replay):
-        
-        # Game clients
-        for p in range(buffer.read_byte()):
+    def __call__(self, buffer, replay):
+        # A fixed length list of player names (includes observers)
+        for player in range(buffer.read_byte()):
             name = buffer.read_string()
-            if len(name) > 0:
+            if name != "":
                 replay.player_names.append(name)
-            buffer.skip(5) #Always all zeros UNKNOWN
-        
-        # UNKNOWN
-        buffer.skip(5) # Unknown
-        buffer.read_chars(4) # Always Dflt
-        buffer.skip(15) #Unknown
+            buffer.skip(5) #Always all zeros
+
+        buffer.skip(24) #Fixed Length data for unknown purpose
+
         sc_account_id = buffer.read_string()
-        
+
         buffer.skip(684) # Fixed Length data for unknown purpose
 
+        # An array of map information, could do much more with this
         while( buffer.read_chars(4).lower() == 's2ma' ):
             buffer.skip(2)
             replay.realm = buffer.read_string(2).lower()
@@ -33,11 +31,11 @@ def read(self, buffer, replay):
 #################################################
 
 class AttributeEventsReader(object):
-    def read(self, buffer, replay):
+    def __call__(self, buffer, replay):
         self.load_header(replay, buffer)
 
         replay.attributes = list()
-        for i in range(0, buffer.read_int(LITTLE_ENDIAN)):
+        for i in range(buffer.read_int(LITTLE_ENDIAN)):
             replay.attributes.append(Attribute([
                     buffer.read_int(LITTLE_ENDIAN),     #Header
                     buffer.read_int(LITTLE_ENDIAN),     #Attr Id
@@ -58,7 +56,7 @@ class DetailsReader(object):
     color_fields = ('a','r','g','b',)
     player_fields = ('name','bnet','race','color','?','?','handicap','?','result')
 
-    def read(self, buffer, replay):
+    def __call__(self, buffer, replay):
         data = buffer.read_data_struct()
 
         for pid, pdata in enumerate(data[0]):
@@ -99,42 +97,36 @@ def read(self, buffer, replay):
 ##################################################
 
 class MessageEventsReader(object):
-    def read(self, buffer, replay):
+    def __call__(self, buffer, replay):
         replay.messages, time = list(), 0
 
-        while(buffer.left != 0):
+        while(buffer.left):
             time += buffer.read_timestamp()
             player_id = buffer.read_byte() & 0x0F
             flags = buffer.read_byte()
-            
+
             if flags & 0xF0 == 0x80:
                 # Pings, TODO: save and use data somewhere
                 if flags & 0x0F == 3:
                     x = buffer.read_int(LITTLE_ENDIAN)
                     y = buffer.read_int(LITTLE_ENDIAN)
-                # Some sort of header code
+
+                # Store recieved messages to later determine the recording
+                # player by process of elimination during post-processing
                 elif flags & 0x0F == 0:
                     buffer.skip(4) # UNKNOWN
-                    # XXX why?
                     replay.other_people.add(player_id)
-            
+
             elif flags & 0x80 == 0:
-                target = flags & 0x03
-                length = buffer.read_byte()
-                
-                # Flags for additional length in message
-                if flags & 0x08:
-                    length += 64
-                if flags & 0x10:
-                    length += 128
-                    
+                target,extension = flags & 0x03, (flags & 0x18) << 3
+                length = buffer.read_byte() + extension
                 text = buffer.read_chars(length)
                 replay.messages.append(Message(time, player_id, target, text))
 
 ####################################################
 
 class GameEventsBase(object):
-    def read(self, buffer, replay):
+    def __call__(self, buffer, replay):
         replay.events, frames = list(), 0
 
         PARSERS = {
@@ -150,8 +142,7 @@ def read(self, buffer, replay):
             start = buffer.cursor
 
             frames += buffer.read_timestamp()
-            pid = buffer.shift(5)
-            type, code = buffer.shift(3), buffer.read_byte()
+            pid,type,code = buffer.shift(5), buffer.shift(3), buffer.read_byte()
             #print "Type %X - Code %X - Start %X" % (type,code,start)
 
             parser = PARSERS.get(type,lambda x:None)(code)