refs #75, don't use {} for v2.6 support.

Conflicts:

	sc2reader/data/__init__.py
	sc2reader/objects.py

Author: GraylinKim

sc2reader/data/__init__.py

@@ -245,7 +245,7 @@ def __init__(self, unit_id):
         self.id = unit_id
 
     def __str__(self):
-        return "{} [{:X}]".format(self.name, self.id)
+        return "{0} [{1:X}]".format(self.name, self.id)
 
     def __repr__(self):
         return str(self)

sc2reader/events.py

@@ -113,7 +113,7 @@ def __init__(self, frames, pid, event_type, x, y, distance, pitch, yaw, height_o
         self.height_offset = height_offset
 
     def __str__(self):
-        return self._str_prefix() + "{} at ({}, {})".format(self.name, self.x,self.y)
+        return self._str_prefix() + "{0} at ({1}, {2})".format(self.name, self.x,self.y)
 
 class PlayerActionEvent(GameEvent):
     name = 'PlayerActionEvent'
@@ -132,7 +132,7 @@ def __init__(self, frames, pid, event_type, target, minerals, vespene, terrazine
         self.custom = custom
 
     def __str__(self):
-        return self._str_prefix() + " transfer {} minerals, {} gas, {} terrazine, and {} custom to {}" % (self.minerals, self.vespene, self.terrazine, self.custom, self.reciever)
+        return self._str_prefix() + " transfer {0} minerals, {1} gas, {2} terrazine, and {3} custom to {4}" % (self.minerals, self.vespene, self.terrazine, self.custom, self.reciever)
 
     def load_context(self, replay):
         super(SendResourceEvent, self).load_context(replay)
@@ -151,7 +151,7 @@ def __init__(self, frames, pid, event_type, minerals, vespene, terrazine, custom
         self.custom = custom
 
     def __str__(self):
-        return self._str_prefix() + " requests {} minerals, {} gas, {} terrazine, and {} custom" % (self.minerals, self.vespene, self.terrazine, self.custom)
+        return self._str_prefix() + " requests {0} minerals, {1} gas, {2} terrazine, and {3} custom" % (self.minerals, self.vespene, self.terrazine, self.custom)
 
 @loggable
 class AbilityEvent(PlayerActionEvent):

sc2reader/factories.py

@@ -254,9 +254,9 @@ def __init__(self, cache_dir, **options):
         super(FileCachedSC2Factory, self).__init__(**options)
         self.cache_dir = os.path.abspath(cache_dir)
         if not os.path.isdir(self.cache_dir):
-            raise ValueError("cache_dir ({}) must be an existing directory.".format(self.cache_dir))
+            raise ValueError("cache_dir ({0}) must be an existing directory.".format(self.cache_dir))
         elif not os.access(self.cache_dir, os.F_OK | os.W_OK | os.R_OK ):
-            raise ValueError("Must have read/write access to {} for local file caching.".format(self.cache_dir))
+            raise ValueError("Must have read/write access to {0} for local file caching.".format(self.cache_dir))
 
     def cache_has(self, cache_key):
         return os.path.exists(self.cache_path(cache_key))

sc2reader/objects.py

@@ -185,7 +185,7 @@ def __init__(self, pid, name):
     def __repr__(self):
         return str(self)
     def __str__(self):
-        return "Player {} - {}".format(self.pid, self.name)
+        return "Player {0} - {1}".format(self.pid, self.name)
 
 class Player(Person):
     """
@@ -301,14 +301,14 @@ def __init__(self, pid):
 
     def __str__(self):
         if not self.is_ai:
-            return '{} - {} - {}/{}/'.format(self.teamid, self.race, self.subregion, self.bnetid)
+            return '{0} - {1} - {2}/{3}/'.format(self.teamid, self.race, self.subregion, self.bnetid)
         else:
-            return '{} - {} - AI'.format(self.teamid, self.race)
+            return '{0} - {1} - AI'.format(self.teamid, self.race)
 
     def get_stats(self):
         s = ''
         for k in self.stats:
-            s += '{}: {}\n'.format(self.stats_pretty_names[k], self.stats[k])
+            s += '{0}: {1}\n'.format(self.stats_pretty_names[k], self.stats[k])
         return s.strip()
 
 # TODO: Are there libraries with classes like this in them

sc2reader/plugins/replay.py

@@ -138,7 +138,7 @@ def SelectionTracker(replay):
             if error:
                 person.selection_errors += 1
                 if debug:
-                    logger.warn("Error detected in deselection mode {}.".format(event.deselect[0]))
+                    logger.warn("Error detected in deselection mode {0}.".format(event.deselect[0]))
 
         person.selection = player_selection
         # Not a real lock, so don't change it!

sc2reader/readers.py

@@ -270,16 +270,16 @@ def __call__(self, data, replay):
 
                 # Otherwise throw a read error
                 else:
-                    raise ReadError("Event type {} unknown at position {}.".format(hex(event_type),hex(event_start)), event_type, event_start, replay, game_events, data)
+                    raise ReadError("Event type {0} unknown at position {1}.".format(hex(event_type),hex(event_start)), event_type, event_start, replay, game_events, data)
 
                 byte_align()
                 event_start = tell()
 
             return game_events
         except ParseError as e:
-            raise ReadError("Parse error '{}' unknown at position {}.".format(e.msg, hex(event_start)), event_type, event_start, replay, game_events, data)
+            raise ReadError("Parse error '{0}' unknown at position {1}.".format(e.msg, hex(event_start)), event_type, event_start, replay, game_events, data)
         except EOFError as e:
-            raise ReadError("EOFError error '{}' unknown at position {}.".format(e.msg, hex(event_start)), event_type, event_start, replay, game_events, data)
+            raise ReadError("EOFError error '{0}' unknown at position {1}.".format(e.msg, hex(event_start)), event_type, event_start, replay, game_events, data)
 
 
 
@@ -333,7 +333,7 @@ def player_hotkey_event(self, data, fstamp, pid, event_type):
         elif action == 2:
             return GetFromHotkeyEvent(fstamp, pid, event_type, hotkey, overlay)
         else:
-            raise ParseError("Hotkey Action '{}' unknown".format(hotkey))
+            raise ParseError("Hotkey Action '{0}' unknown".format(hotkey))
 
     def player_send_resource_event(self, data, fstamp, pid, event_type):
         target = data.read_bits(4)
@@ -519,4 +519,4 @@ def player_selection_event(self, data, fstamp, pid, event_type):
 
         unit_types = chain(*[[utype]*count for (utype, count) in unit_types])
         units = list(zip(unit_ids, unit_types))
-        return SelectionEvent(fstamp, pid, event_type, bank, units, overlay)
+        return SelectionEvent(fstamp, pid, event_type, bank, units, overlay)

sc2reader/resources.py

@@ -297,7 +297,7 @@ def load_details(self):
             elif details.os == 1:
                 self.os = "Mac"
             else:
-                raise ValueError("Unknown operating system {} detected.".format(details.os))
+                raise ValueError("Unknown operating system {0} detected.".format(details.os))
 
             self.windows_timestamp = details.file_time
             self.unix_timestamp = utils.windows_to_unix(self.windows_timestamp)
@@ -375,7 +375,7 @@ def load_players(self):
             player.team = self.team[team_number]
 
             # Do basic win/loss processing from details data
-            if   pdata.result == 1:
+            if pdata.result == 1:
                 player.team.result = "Win"
                 self.winner = player.team
             elif pdata.result == 2:
@@ -450,7 +450,7 @@ def load_players(self):
                 self.recorder.recorder = True
             else:
                 self.recorder = None
-                self.logger.error("{} possible recorders remain: {}".format(len(recorders), recorders))
+                self.logger.error("{0} possible recorders remain: {1}".format(len(recorders), recorders))
 
         player_names = sorted(map(lambda p: p.name, self.people))
         hash_input = self.gateway+":"+','.join(player_names)
@@ -551,7 +551,7 @@ def _get_reader(self, data_file):
             if callback(self):
                 return reader
         else:
-            raise ValueError("Valid {} reader could not found for build {}".format(data_file, self.build))
+            raise ValueError("Valid {0} reader could not found for build {1}".format(data_file, self.build))
 
     def _get_datapack(self):
         for callback, datapack in self.registered_datapacks:
@@ -947,7 +947,7 @@ def load_player_builds(self):
                                 build_index=command[1] >> 16
                             ))
             else:
-                self.logger.warn("Unknown item in build order, key = {}".format(translation_key))
+                self.logger.warn("Unknown item in build order, key = {0}".format(translation_key))
 
         # Once we've compiled all the build commands we need to make
         # sure they are properly sorted for presentation.
@@ -1021,7 +1021,7 @@ def load_players(self):
             self.player[player.pid] = player
 
     def __str__(self):
-        return "{} - {} {}".format(self.start_time,self.game_length,
+        return "{0} - {1} {2}".format(self.start_time,self.game_length,
                                          'v'.join(''.join(self.players[p].race[0] for p in self.teams[tid]) for tid in self.teams))
 
 

sc2reader/scripts/sc2boprinter.py

@@ -14,11 +14,11 @@ def main():
     args = parser.parse_args()
     for r in sc2reader.load_game_summaries(args.path):
         print("\n"+"-"*40+"\n")
-        print("= {} =".format(r))
+        print("= {0} =".format(r))
         for p in r.players:
-            print("== {} - {} ==".format(p.race, p.bnetid if not p.is_ai else "AI"))
+            print("== {0} - {1} ==".format(p.race, p.bnetid if not p.is_ai else "AI"))
             for order in r.build_orders[p.pid]:
-                print("{:0>2}:{:0>2}  {:<35} {:>2}/{}".format(order['time'] / 60,
+                print("{0:0>2}:{1:0>2}  {2:<35} {3:>2}/{4}".format(order['time'] / 60,
                                                                   order['time'] % 60,
                                                                   order['order']['name'],
                                                                   order['supply'],

sc2reader/utils.py

@@ -103,7 +103,7 @@ def read_byte(self):
 
     def read_short(self, endian=LITTLE_ENDIAN):
         #if self.bytes_left() < 2:
-        #    raise EOFError("Cannot read short; only {} bytes left in buffer".format(self.left))
+        #    raise EOFError("Cannot read short; only {0} bytes left in buffer".format(self.left))
 
         if self.bit_shift == 0:
             return struct.unpack(endian+'H', self.read(2))[0]
@@ -120,7 +120,7 @@ def read_short(self, endian=LITTLE_ENDIAN):
 
     def read_int(self, endian=LITTLE_ENDIAN):
         #if self.bytes_left() < 4:
-        #    raise EOFError("Cannot read int; only {} bytes left in buffer".format(self.left))
+        #    raise EOFError("Cannot read int; only {0} bytes left in buffer".format(self.left))
 
         if self.bit_shift == 0:
             return struct.unpack(endian+'I', self.read(4))[0]
@@ -137,7 +137,7 @@ def read_int(self, endian=LITTLE_ENDIAN):
 
     def read_bits(self, bits):
         #if self.bytes_left()*8 < bits-(8-self.bit_shift):
-        #    raise EOFError("Cannot read {} bits. only {} bits left in buffer.".format(bits, (self.length-self.tell()+1)*8-self.bit_shift))
+        #    raise EOFError("Cannot read {0} bits. only {1} bits left in buffer.".format(bits, (self.length-self.tell()+1)*8-self.bit_shift))
         bit_shift = self.bit_shift
         if bit_shift!=0:
             bits_left = 8-bit_shift
@@ -189,7 +189,7 @@ def read_bits(self, bits):
 
     def read_bytes(self, bytes):
         #if self.bytes_left() < bytes:
-        #    raise EOFError("Cannot read {} bytes. only {} bytes left in buffer.".format(bytes, self.length-self.tell()))
+        #    raise EOFError("Cannot read {0} bytes. only {1} bytes left in buffer.".format(bytes, self.length-self.tell()))
 
         if self.bit_shift==0:
             return self.read(bytes)
@@ -470,7 +470,7 @@ def extract_data_file(data_file, archive):
 
     except Exception as e:
         trace = sys.exc_info()[2]
-        raise exceptions.MPQError("Unable to extract file: {}".format(data_file),e), None, trace
+        raise exceptions.MPQError("Unable to extract file: {0}".format(data_file),e), None, trace
 
 def read_header(replay_file):
     # Extract useful header information from the MPQ files. This information
@@ -481,7 +481,7 @@ def read_header(replay_file):
 
     # Sanity check that the input is in fact an MPQ file
     if data.length==0 or data.read(4) != "MPQ\x1b":
-        msg = "File '{}' is not an MPQ file";
+        msg = "File '{0}' is not an MPQ file";
         raise exceptions.FileError(msg.format(getattr(replay_file, 'name', '<NOT AVAILABLE>')))
 
     max_data_size = data.read_int(LITTLE_ENDIAN)