A massive lump of a commit. Sorry guys.

This introduces several different utility classes and makes several
changes to the player object among other things. I'd split this work
up but that'd take too much time and its more important that the code
gets up there.

Author: GraylinKim

sc2reader/objects.py

@@ -1,9 +1,11 @@
 from constants import LOCALIZED_RACES
 from collections import defaultdict
 
+import datetime
+
 from .constants import *
 from .data import GameObject, ABILITIES
-from .utils import PersonDict, Selection, read_header, AttributeDict
+from .utils import PersonDict, Selection, read_header, AttributeDict, Length
 
 from collections import namedtuple
 
@@ -39,6 +41,9 @@ def __init__(self,number):
         self.players = list()
         self.result = "Unknown"
 
+    def __iter__(self):
+        return self.players.__iter__()
+
 
 class Replay(object):
 
@@ -52,7 +57,7 @@ def __init__(self, replay_file, **options):
         self.build = self.versions[4]
         self.release_string = "%s.%s.%s.%s" % tuple(self.versions[1:5])
         self.seconds = self.frames/16
-        self.length = (self.seconds/60, self.seconds%60)
+        self.length = Length(seconds=self.seconds)
 
         #default values, filled in during file read
         self.player_names = list()
@@ -252,6 +257,9 @@ def __repr__(self):
     def result(self):
         return self.team.result
 
+    def format(self, format_string):
+        return format_string.format(**self.__dict__)
+
 class Event(object):
     name = 'BaseEvent'
     def apply(self): pass
@@ -298,6 +306,7 @@ class AbilityEvent(Event):
     name = 'AbilityEvent'
     def __init__(self, framestamp, player, type, code, ability):
         super(AbilityEvent, self).__init__(framestamp, player, type, code)
+        print "{0}: {1}".format(self.name,ability)
         self.ability = ability
 
     def apply(self):

sc2reader/parsers.py

@@ -39,7 +39,7 @@ def parse_selection_event(self, buffer, frames, type, code, pid):
         object_types = chain(*[[object_type,]*count for (object_type, count) in object_types])
         objects = zip(object_ids, object_types)
 
-        return AbilityEvent(frames, pid, type, code, None)
+        return SelectionEvent(frames, pid, type, code, None)
 
     def parse_hotkey_event(self, buffer, frames, type, code, pid):
         hotkey = code >> 4
@@ -108,13 +108,13 @@ def parse_ability_event(self, buffer, frames, type, code, pid):
                     return TargetAbilityEvent(frames, pid, type, code, ability, target)
 
                 else:
-                    return AbilityEvent(frames,pid,type,code,None)
+                    return AbilityEvent(frames,pid,type,code,ability)
 
         elif atype & 0x40: # location/move
             if flag == 0x08:
                 # coordinates (4), ?? (6)
                 location = buffer.read_coordinate()
-                buffer.skip(5)
+                print buffer.read_hex(5)
                 return LocationAbilityEvent(frames, pid, type, code, None, location)
 
             elif flag in (0x04,0x05,0x07):
@@ -249,7 +249,7 @@ def parse_ability_event(self, buffer, frames, type, code, pid):
                     return TargetAbilityEvent(frames, pid, type, code, ability, target)
 
                 else:
-                    return AbilityEvent(frames,pid,type,code,None)
+                    return AbilityEvent(frames,pid,type,code,ability)
 
         elif atype & 0x40: # location/move ??
             h = buffer.read_hex(2)

sc2reader/processors.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from .objects import *
-from .utils import key_in_bases, windows_to_unix
+from .utils import key_in_bases, windows_to_unix, Length
 from datetime import datetime
 
 def Full(replay):
@@ -87,13 +87,13 @@ def Full(replay):
         if   pdata.result == 1: player.team.result = "Win"
         elif pdata.result == 2: player.team.result = "Loss"
 
-        player.chosen_race = attributes['Race']
+        player.pick_race = attributes['Race']
+        player.play_race = LOCALIZED_RACES.get(pdata.race, pdata.race)
         player.difficulty = attributes['Difficulty']
         player.type = attributes['Player Type']
         player.uid = pdata.bnet.uid
         player.subregion = pdata.bnet.subregion
         player.handicap = pdata.handicap
-        player.actual_race = LOCALIZED_RACES.get(pdata.race, pdata.race)
 
         # We need initData for the realm which is required to build the url!
         if 'initData' in replay.raw and replay.realm:
@@ -112,6 +112,10 @@ def Full(replay):
         replay.player[pid] = player
         replay.person[pid] = player
 
+    #Create an store an ordered lineup string
+    for team in replay.teams:
+        team.lineup = sorted(player.play_race[0].upper() for player in team)
+
     if 'initData' in replay.raw:
         # Create observers out of the leftover names gathered from initData
         all_players = replay.raw.initData.player_names

sc2reader/utils.py

@@ -1,10 +1,12 @@
+import argparse
 import cStringIO
 import fnmatch
 import os
 import re
 import struct
+import textwrap
 
-import exceptions
+import sc2reader.exceptions
 
 from itertools import groupby
 
@@ -535,20 +537,22 @@ def read_header(file):
     return header_data[1].values(),header_data[3]
 
 
-def _allow(filename, regex):
+
+def _allow(filename, regex=None, allow=True):
     name, ext = os.path.splitext(filename)
     if ext.lower() != ".sc2replay": return False
-    return re.match(regex, name) if regex else True
+    return allow == re.match(regex, name) if regex else allow
 
-def get_files( path, regex=None, exclude=[],
+def get_files( path, regex=None, allow=True, 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))
 
     # Curry the function to prime it for use in the filter function
-    allow = lambda filename: _allow(filename, regex)
+    allow = lambda filename: _allow(filename, regex, allow)
 
     # You can't get more than one file from a file name!
     if os.path.isfile(path):
@@ -567,3 +571,79 @@ def get_files( path, regex=None, exclude=[],
         depth -= 1
 
     return files
+
+from datetime import timedelta
+class Length(timedelta):
+    @property
+    def hours(self):
+        return self.seconds/3600
+
+    @property
+    def mins(self):
+        return self.seconds/60
+
+    @property
+    def secs(self):
+        return self.seconds%60
+
+    def __str__(self):
+        if self.hours:
+            return "{0:0>2}.{1:0>2}.{2:0>2}".format(self.hours,self.mins,self.secs)
+        else:
+            return "{0:0>2}.{1:0>2}".format(self.mins,self.secs)
+
+class Formatter(argparse.RawTextHelpFormatter):
+    """FlexiFormatter which respects new line formatting and wraps the rest
+
+    Example:
+        >>> parser = argparse.ArgumentParser(formatter_class=FlexiFormatter)
+        >>> parser.add_argument('a',help='''\
+        ...     This argument's help text will have this first long line\
+        ...     wrapped to fit the target window size so that your text\
+        ...     remains flexible.
+        ...
+        ...         1. This option list
+        ...         2. is still persisted
+        ...         3. and the option strings get wrapped like this\
+        ...            with an indent for readability.
+        ...
+        ...     You must use backslashes at the end of lines to indicate that\
+        ...     you want the text to wrap instead of preserving the newline.
+        ... ''')
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    @classmethod
+    def new(cls, **options):
+        return lambda prog: Formatter(prog, **options)
+
+    def _split_lines(self, text, width):
+        lines = list()
+        main_indent = len(re.match(r'( *)',text).group(1))
+        # Wrap each line individually to allow for partial formatting
+        for line in text.splitlines():
+
+            # Get this line's indent and figure out what indent to use
+            # if the line wraps. Account for lists of small variety.
+            indent = len(re.match(r'( *)',line).group(1))
+            list_match = re.match(r'( *)(([*-+>]+|\w+\)|\w+\.) +)',line)
+            if(list_match):
+                sub_indent = indent + len(list_match.group(2))
+            else:
+                sub_indent = indent
+
+            # Textwrap will do all the hard work for us
+            line = self._whitespace_matcher.sub(' ', line).strip()
+            new_lines = textwrap.wrap(
+                text=line,
+                width=width,
+                initial_indent=' '*(indent-main_indent),
+                subsequent_indent=' '*(sub_indent-main_indent),
+            )
+
+            # Blank lines get eaten by textwrap, put it back with [' ']
+            lines.extend(new_lines or [' '])
+
+        return lines