Add built-in summary, match info, and match history support.

Author: GraylinKim

sc2reader/__init__.py

@@ -26,8 +26,13 @@
 load_replay = __defaultSC2Reader.load_replay
 load_maps = __defaultSC2Reader.load_maps
 load_map = __defaultSC2Reader.load_map
-load_summaries = __defaultSC2Reader.load_summaries
-load_summary = __defaultSC2Reader.load_summary
+load_game_summaries = __defaultSC2Reader.load_game_summaries
+load_game_summary = __defaultSC2Reader.load_game_summary
+load_match_infos = __defaultSC2Reader.load_match_infos
+load_match_info = __defaultSC2Reader.load_match_info
+load_match_histories = __defaultSC2Reader.load_match_histories
+load_match_history = __defaultSC2Reader.load_match_history
+
 
 configure = __defaultSC2Reader.configure
 reset = __defaultSC2Reader.reset

sc2reader/factories.py

@@ -14,7 +14,7 @@
 from sc2reader import exceptions
 from sc2reader import utils
 from sc2reader import log_utils
-from sc2reader.resources import Replay, Map, Summary
+from sc2reader.resources import Replay, Map, GameSummary, MatchInfo, MatchHistory
 
 class SC2Factory(object):
     """
@@ -133,8 +133,12 @@ def load_resources(self, resources, resource_loader, options=None, **new_options
             if re.match(r'https?://',resources):
                 yield resource_loader(resources, options=options)
             else:
-                for resource in utils.get_replay_files(resources, **options):
-                    yield resource_loader(resource, options=options)
+                for resource in utils.get_files(resources, **options):
+                    try:
+                        yield resource_loader(resource, options=options)
+                    except Exception as e:
+                        print "\n\n\nFAILURE!!!\n\n\n"
+                        yield None
 
         # File like object?
         elif hasattr(resources,'read'):
@@ -175,17 +179,17 @@ def load_resource(self, resource, options=None, **new_options):
 
         return (resource, resource_name)
 
-    def load_summaries(self, gs, options=None, **new_options):
+    def load_game_summaries(self, gs, options=None, **new_options):
         """
-        Loads a collection of replays. See load_resources for detailed parameter
+        Loads a collection of game summaries. See load_resources for detailed parameter
         documentation.
 
-        :rtype: generator(:class:`Map`)
+        :rtype: generator(:class:`GameSummary`)
         """
-        for s in self.load_resources(gs, self.load_summary, options=options, **new_options):
+        for s in self.load_resources(gs, self.load_game_summary, options=options, extensions=['.s2gs'], **new_options):
             yield s
 
-    def load_summary(self, summary_file, options=None, **new_options):
+    def load_game_summary(self, summary_file, options=None, **new_options):
         """
         Loads the specified summary using the current factory settings with the
         specified overrides.
@@ -199,16 +203,87 @@ def load_summary(self, summary_file, options=None, **new_options):
         :param new_options: Options values to override current factory settings
             while loading this map.
 
-        :rtype: :class:`Replay`
+        :rtype: :class:`GameSummary`
         """
         options = options or utils.merged_dict(self.options, new_options)
         resource, name = self.load_resource(summary_file, options=options)
-        s = Summary(resource, name, **options)
+        s2gs = GameSummary(resource, name, **options)
+
+        # Load summary procedure here!
+        #
+
+        return s2gs
+
+    def load_match_infos(self, infos, options=None, **new_options):
+        """
+        Loads a collection of MatchInfos. See load_resources for detailed
+        parameter documentation.
+
+        :rtype: generator(:class:`MatchInfo`)
+        """
+        for s2mi in self.load_resources(infos, self.load_match_info, options=options, extensions=['.s2mi'], **new_options):
+            yield s2mi
+
+    def load_match_info(self, info_file, options=None, **new_options):
+        """
+        Loads the specified match info using the current factory settings with
+        the specified overrides.
+
+        :param info_file: An open file object or path/url to a single file
+
+        :param None options: When options are passed directly into the options
+            parameter the current factory settings are ignored and only the
+            specified options are used during replay load.
+
+        :param new_options: Options values to override current factory settings
+            while loading this map.
+
+        :rtype: :class:`MatchInfo`
+        """
+        options = options or utils.merged_dict(self.options, new_options)
+        resource, name = self.load_resource(info_file, options=options)
+        s2mi = MatchInfo(resource, name, **options)
+
+        # Load summary procedure here!
+        #
+
+        return s2mi
+
+    def load_match_histories(self, histories, options=None, **new_options):
+        """
+        Loads a collection of match history files. See load_resources for
+        detailed parameter documentation.
+
+        :rtype: generator(:class:`MatchHistory`)
+        """
+        for s2mh in self.load_resources(histories, self.load_match_history, options=options, extensions=['.s2mh'], **new_options):
+            yield s2mh
+
+    def load_match_history(self, history_file, options=None, **new_options):
+        """
+        Loads the specified match info using the current factory settings with
+        the specified overrides.
+
+        :param history_file: An open file object or path/url to a single file
+
+        :param None options: When options are passed directly into the options
+            parameter the current factory settings are ignored and only the
+            specified options are used during replay load.
+
+        :param new_options: Options values to override current factory settings
+            while loading this map.
+
+        :rtype: :class:`MatchHistory`
+        """
+        options = options or utils.merged_dict(self.options, new_options)
+        resource, name = self.load_resource(history_file, options=options)
+        print name
+        s2mh = MatchHistory(resource, name, **options)
 
         # Load summary procedure here!
         #
 
-        return s
+        return s2mh
 
     def load_maps(self, maps, options=None, **new_options):
         """
@@ -217,7 +292,7 @@ def load_maps(self, maps, options=None, **new_options):
 
         :rtype: generator(:class:`Map`)
         """
-        for m in self.load_resources(maps, self.load_map, options=options, **new_options):
+        for m in self.load_resources(maps, self.load_map, options=options, extensions=['.s2ma'], **new_options):
             yield m
 
     def load_map(self, map_file, options=None, **new_options):
@@ -253,7 +328,7 @@ def load_replays(self, replays, options=None, **new_options):
 
         :rtype: generator(:class:`Replay`)
         """
-        for r in self.load_resources(replays, self.load_replay, options=options, **new_options):
+        for r in self.load_resources(replays, self.load_replay, options=options, extensions=['.sc2replay'], **new_options):
             yield r
 
     def load_replay(self, replay_file, options=None, **new_options):

sc2reader/resources.py

@@ -396,11 +396,10 @@ def read_game_strings(self):
             elif parts[0] == 'DocInfo/DescLong':
                 self.description = parts[1]
 
-class Summary(Resource):
+class GameSummary(Resource):
     url_template = 'http://{0}.depot.battle.net:1119/{1}.s2ma'
-
     def __init__(self, summary_file, filename=None, **options):
-        super(Summary, self).__init__(summary_file, filename,**options)
+        super(GameSummary, self).__init__(summary_file, filename,**options)
         self.data = zlib.decompress(summary_file.read()[16:])
         self.parts = list()
         buffer = utils.ReplayBuffer(self.data)
@@ -409,3 +408,16 @@ def __init__(self, summary_file, filename=None, **options):
             print str(part)+"\n\n\n"
             self.parts.append(buffer.read_data_struct())
         print len(self.parts)
+
+class MatchInfo(Resource):
+    url_template = 'http://{0}.depot.battle.net:1119/{1}.s2ma'
+    def __init__(self, info_file, filename=None, **options):
+        super(MatchInfo, self).__init__(info_file, filename,**options)
+        self.data = utils.ReplayBuffer(info_file).read_data_struct()
+
+
+class MatchHistory(Resource):
+    url_template = 'http://{0}.depot.battle.net:1119/{1}.s2ma'
+    def __init__(self, history_file, filename=None, **options):
+        super(MatchHistory, self).__init__(history_file, filename,**options)
+        self.data = utils.ReplayBuffer(history_file).read_data_struct()

sc2reader/utils.py

@@ -261,19 +261,36 @@ def read_timestamp(self):
         else:
             raise ValueError()
 
-    def read_data_struct(self):
+    def read_data_struct(self, indent=0, key=None):
         """
         Read a Blizzard data-structure. Structure can contain strings, lists,
         dictionaries and custom integer types.
         """
         #The first byte serves as a flag for the type of data to follow
         datatype = self.read_byte()
+        prefix = hex(self.tell())+"\t"*indent
+        if key != None:
+            prefix+="{0}: {1}".format(key, datatype)
+
+        #print prefix
 
         if datatype == 0x00:
             #0x00 is an array where the first X bytes mark the number of entries in
             #the array. See variable int documentation for details.
             entries = self.read_variable_int()
-            return [self.read_data_struct() for i in range(entries)]
+            #print "Entries, ",entries
+            #print self.peek(10)
+            return [self.read_data_struct(indent+1,i) for i in range(entries)]
+
+        if datatype == 0x01:# or datatype == 0x0A:
+            #0x01 is an array where the first X bytes mark the number of entries in
+            #the array. See variable int documentation for details.
+            #print self.peek(10)
+            self.read_chars(2).encode("hex")
+            #print self.peek(10)
+            entries = self.read_variable_int()
+            #print "Entries, ",entries
+            return [self.read_data_struct(indent+1,i) for i in range(entries)]
 
         if datatype == 0x02:
             #0x02 is a byte string with the first byte indicating
@@ -284,14 +301,17 @@ def read_data_struct(self):
             #0x03 is an unknown data type where the first byte appears
             #to have no effect and kicks back the next instruction
             flag = self.read_byte()
-            return self.read_data_struct()
+            return self.read_data_struct(indent,key)
 
         elif datatype == 0x04:
             #0x04 is an unknown data type where the first byte of information
             #is a switch (1 or 0) that can trigger another structure to be
             #read.
-            if self.read_byte():
-                return self.read_data_struct()
+            flag = self.read_byte()
+            #if flag == 0x04:
+            #    flag = self.read_byte()
+            if flag:
+                return self.read_data_struct(indent,key)
             else:
                 return 0
 
@@ -301,18 +321,25 @@ def read_data_struct(self):
             #When looping through the pairs, the first byte is the key,
             #followed by the serialized data object value
             data = dict()
-            for i in range(self.read_count()):
+            #print self.peek(10)
+            entries = self.read_count()
+            #print "Key Entries, ",entries
+            for i in range(entries):
                 key = self.read_count()
-                data[key] = self.read_data_struct() #Done like this to keep correct parse order
+                data[key] = self.read_data_struct(indent+1,key) #Done like this to keep correct parse order
             return data
 
         elif datatype == 0x06:
             return self.read_byte()
         elif datatype == 0x07:
             return self.read_chars(4)
         elif datatype == 0x09:
+            #print self.peek(10)
             return self.read_variable_int()
-
+        """
+        elif datatype == 0x0A:
+            return self.read_byte()
+        """
         raise TypeError("Unknown Data Structure: '%s'" % datatype)
 
     def read_object_type(self, read_modifier=False):
@@ -652,18 +679,21 @@ def merged_dict(a, b):
     c.update(b)
     return c
 
-def sc2replay_ext(filename):
+def extension_filter(filename, extensions):
     name, ext = os.path.splitext(filename)
-    return ext.lower() == ".sc2replay"
+    return ext.lower() in extensions
 
-def get_replay_files(path, exclude=[], depth=-1, followlinks=False, **extras):
+import functools
+def get_files(path, extensions=['.sc2replay'], exclude=[], depth=-1, followlinks=False, **extras):
     #os.walk and os.path.isfile fail silently. We want to be loud!
     if not os.path.exists(path):
         raise ValueError("Location `{0}` does not exist".format(path))
 
+    filtr_func = functools.partial(extension_filter, extensions=extensions)
+
     # os.walk can't handle file paths, only directories
     if os.path.isfile(path):
-        return [path] if sc2replay_ext(path) else []
+        return [path] if filtr_func(path,extensions) else []
 
     files = list()
     for root, directories, filenames in os.walk(path, followlinks=followlinks):
@@ -673,7 +703,7 @@ def get_replay_files(path, exclude=[], depth=-1, followlinks=False, **extras):
                 directories.remove(directory)
 
         # Extend our return value only with the allowed file type and regex
-        allowed_files = filter(sc2replay_ext, filenames)
+        allowed_files = filter(filtr_func, filenames)
         files.extend(os.path.join(root, filename) for filename in allowed_files)
         depth -= 1