Completely restructures the back end to be configurable and more pluggable. Also fixes several bugs. This should have been broken into about 100 commits

Author: GraylinKim

sc2reader/__init__.py

@@ -1,3 +1,86 @@
-from replay import Replay
+from mpyq import MPQArchive
+from utils import ByteStream
+from objects import Replay
+from readers import *
+from processors import *
+from collections import OrderedDict
 
-__version__ = "0.1.0"
+__version__ = "0.1.0"
+
+import os
+
+class DefaultConfig(object):
+    def __init__(self):
+        self.readers = OrderedDict()
+        self.readers['replay.initData'] = [ ReplayInitDataReader() ]
+        self.readers['replay.details'] = [ ReplayDetailsReader() ]
+        self.readers['replay.attributes.events'] = [ AttributeEventsReader_17326(), AttributeEventsReader() ]
+        self.readers['replay.message.events'] = [ MessageEventsReader() ]
+        self.readers['replay.game.events'] = [ GameEventsReader_17326(), GameEventsReader_16561(), GameEventsReader() ]
+        
+        self.processors = [
+                PeopleProcessor,
+                AttributeProcessor,
+                TeamsProcessor,
+                MessageProcessor,
+                RecorderProcessor,
+                EventProcessor,
+                ApmProcessor,
+                ResultsProcessor
+            ]
+
+def read(location,config=DefaultConfig()):
+    if not os.path.exists(location):
+        raise ValueError("Location must exist")
+    
+    if os.path.isdir(location):
+        replays = list()
+        for location in os.list_files(location):
+            replays.extend(read(location,config))
+        return replays
+    else:
+        return read_file(location,config)
+    
+def read_file(filename,config=DefaultConfig()):
+    if(os.path.splitext(filename)[1].lower() != '.sc2replay'):
+        raise TypeError("Target file must of the SC2Replay file extension")
+    
+    with open(filename) as replay_file:
+        release,frames = read_header(replay_file)
+        replay = Replay(filename,release,frames)
+        archive = MPQArchive(filename,listfile=False)
+        
+        #Extract and Parse the relevant files
+        for file,readers in config.readers.iteritems():
+            for reader in readers:
+                if reader.reads(replay.build):
+                    reader.read(archive.read_file(file),replay)
+                    break
+            else:
+                raise NotYetImplementedError("No parser was found that accepted the replay file;check configuration")
+
+        #Do cleanup and post processing
+        for process in config.processors:
+            replay = process(replay)
+            
+        return replay
+    
+def read_header(file):
+    source = ByteStream(file.read())
+    
+    #Check the file type for the MPQ header bytes
+    if source.get_hex(4).upper() != "4D50511B":
+        raise ValueError("File '%s' is not an MPQ file" % file.name)
+    
+    #Extract replay header data, we don't actually use this for anything
+    max_data_size = source.get_little_32() #possibly data max size
+    header_offset = source.get_little_32() #Offset of the second header
+    data_size = source.get_little_32()     #possibly data size
+    
+    #Extract replay attributes from the mpq
+    data = source.parse_serialized_data()
+    
+    #return the release and frames information
+    return data[1],data[3]
+        
+__all__ = [DefaultConfig,read,read_file]

sc2reader/objects.py

@@ -1,5 +1,53 @@
 from data import races
+from collections import defaultdict
+from sc2reader.utils import ByteStream, PersonDict
 
+class Replay(object):
+    
+    def __init__(self, filename, release, frames=0):
+        #Split and offset for matching indexes if they pass in the release string
+        if isinstance(release,basestring): release = [None]+release.split('.') 
+        
+        #Assign all the relevant information to the replay object
+        self.build = release[4]
+        self.versions = (release[1], release[2], release[3], release[4])
+        self.release_string = "%s.%s.%s.%s" % self.versions
+        self.frames, self.seconds = (frames, frames/16)
+        self.length = (self.seconds/60, self.seconds%60)
+        
+        self.player_names = list()
+        self.other_people = set()
+        self.filename = filename
+        self.speed = ""
+        self.type = ""
+        self.category = ""
+        self.is_ladder = False
+        self.is_private = False
+        self.map = ""
+        self.realm = ""
+        self.events = list()
+        self.results = dict()
+        self.teams = defaultdict(list)
+        self.observers = list() #Unordered list of Observer
+        self.players = list() #Unordered list of Player
+        self.people = list() #Unordered list of Players+Observers
+        self.person = PersonDict() #Maps pid to Player/Observer
+        self.events_by_type = dict()
+        self.attributes = list()
+        self.messages = list()
+        self.recorder = None # Player object
+        self.winner_known = False
+
+        # Set in parsers.DetailParser.load, should we hide this?
+        self.file_time = None # Probably number milliseconds since EPOCH
+        
+        # TODO: Test EPOCH differences between MacOsX and Windows
+        # http://en.wikipedia.org/wiki/Epoch_(reference_date)
+        # Notice that Windows and Mac have different EPOCHs, I wonder whether
+        # this is different depending on the OS on which the replay was played.
+        self.date = None # Date when the game was played in local time
+        self.utc_date = None # Date when the game was played in UTC
+        
 class Attribute(object):
 
     def __init__(self, data):
@@ -92,58 +140,11 @@ def __repr__(self):
 
     def __str__(self):
         return "%s: %s" % (self.name, self.value)
-
-
-		
-		
-class Event(object):
-    def __init__(self, elapsed_time, event_type, event_code, global_flag, player_id, 
-                    location=None, bytes=""):
-        self.time, self.seconds = (elapsed_time, elapsed_time/16)
-        self.timestr = "%s:%s" % (self.seconds/60, str(self.seconds%60).rjust(2, "0"))
-        self.type = event_type
-        self.code = event_code
-        self.is_local = (global_flag == 0x0)
-        self.player = player_id
-        self.location = location
-        self.bytes = bytes
-        self.abilitystr = ""
-
-        # Added for convenience
-        self.is_init = (event_type == 0x00)
-        self.is_player_action = (event_type == 0x01)
-        self.is_camera_movement = (event_type == 0x03)
-        self.is_unknown = (event_type == 0x02 or event_type == 0x04 or event_type == 0x05)
-        		
-    def __call__(self, elapsed_time, event_type, global_flag, player_id, event_code, bytes):
-        self.time, self.seconds = (elapsed_time, elapsed_time/16)
-        self.timestr = "%s:%s" % (self.seconds/60, str(self.seconds%60).rjust(2, "0"))
-        self.type = event_type
-        self.code = event_code
-        self.is_local = (global_flag == 0x0)
-        self.player = player_id
-        self.bytes = ""
-        self.abilitystr = ""
-        
-        # Added for convenience
-        self.is_init = (event_type == 0x00)
-        self.is_player_action = (event_type == 0x01)
-        self.is_camera_movement = (event_type == 0x03)
-        self.is_unknown = (event_type == 0x02 or event_type == 0x04 or event_type == 0x05)
-        
-        self.parse(bytes)
-        return self
-	
-    def __str__(self):
-        return "%s - %s - %s" % (self.timestr, self.name, self.abilitystr)
-        
-    def __repr__(self):
-        return str(self)
-
+    
 class Message(object):
 
-    def __init__(self, time, player, target, text):
-        self.time, self.sender, self.target, self.text = time, player, target, text
+    def __init__(self, time, pid, target, text):
+        self.time, self.sender_id, self.target, self.text = time, pid, target, text
         self.seconds = time/16
         self.sent_to_all = (self.target == 0)
         self.sent_to_allies = (self.target == 2)
@@ -156,31 +157,29 @@ def __repr__(self):
         return str(self)
 
 # Actor is a base class for Observer and Player
-class Actor(object):
-    def __init__(self, is_obs):
-        self.pid = None
-        self.name = None
-        self.is_obs = is_obs
+class Person(object):
+    def __init__(self, pid, name):
+        self.pid = pid
+        self.name = name
+        self.is_obs = None
         self.messages = list()
         self.events = list()
-        self.recorder = True # Actual recorder will be determined using the replay.message.events file
+        self.recorder = False # Actual recorder will be determined using the replay.message.events file
 
-class Observer(Actor):
+class Observer(Person):
     def __init__(self, pid, name):
-        Actor.__init__(self, True)
-        self.pid = pid
-        self.name = name
+        super(Observer,self).__init__(pid,name)
+        self.is_obs = True
 
-class Player(Actor):
+class Player(Person):
 
     url_template = "http://%s.battle.net/sc2/en/profile/%s/%s/%s/"
 
     def __init__(self, pid, data, realm="us"):
-        Actor.__init__(self, False)
         # TODO: get a map of realm,subregion => region in here
-        self.pid = pid
+        super(Player,self).__init__(pid,data[0].decode("hex"))
+        self.is_obs = False
         self.realm = realm
-        self.name = data[0].decode("hex")
         self.uid = data[1][4]
         self.subregion = data[1][2]
         self.url = self.url_template % (self.realm, self.uid, self.subregion, self.name)
@@ -197,6 +196,8 @@ def __init__(self, pid, data, realm="us"):
                 ['b', data[3][3]], 
                 ['a', data[3][0]], 
             ])
+            
+        self.result = None
         self.color_hex = "%02X%02X%02X" % (data[3][1], data[3][2], data[3][3])
         self.color_text = "" # The text of the player color (Red, Blue, etc) to be supplied later
         self.handicap = data[6]
@@ -211,3 +212,55 @@ def __str__(self):
 
     def __repr__(self):
         return str(self)
+
+        
+        
+class Event(object):
+    def __init__(self, elapsed_time, event_type, event_code, player_id):
+        self.time, self.seconds = (elapsed_time, elapsed_time/16)
+        self.timestr = "%s:%s" % (self.seconds/60, str(self.seconds%60).rjust(2, "0"))
+        self.type = event_type
+        self.code = event_code
+        self.is_local = (player_id != 16)
+        self.player = player_id
+        self.bytes = bytes
+        self.abilitystr = ""
+
+        # Added for convenience
+        self.is_init = (event_type == 0x00)
+        self.is_player_action = (event_type == 0x01)
+        self.is_camera_movement = (event_type == 0x03)
+        self.is_unknown = (event_type == 0x02 or event_type == 0x04 or event_type == 0x05)
+	
+    def __str__(self):
+        return "%s - %s - %s" % (self.timestr, self.name, self.abilitystr)
+        
+    def __repr__(self):
+        return str(self)
+	
+class UnknownEvent(Event):
+	name = 'UnknownEvent'
+	
+class PlayerJoinEvent(Event):
+	name = 'PlayerJoin'
+	
+class GameStartEvent(Event):
+    name = 'GameStart'
+    
+class PlayerLeaveEvent(Event):
+	name = 'PlayerLeave'
+    
+class AbilityEvent(Event):
+    name = 'AbilityEvent'
+
+class ResourceTransferEvent(Event):
+    name = 'ResourceTransfer'
+
+class HotkeyEvent(Event):
+    name = 'HotkeyEvent'
+    
+class SelectionEvent(Event):
+    name = 'SelectionEvent'
+    
+class CameraMovementEvent(Event):
+    name = 'CameraMovement'