Python 2.6 does not support auto-numbering in str.format()

asyncio/base_events.py

@@ -339,7 +339,7 @@ class BaseEventLoop(events.AbstractEventLoop):
                                 exc = OSError(
                                     exc.errno, 'error while '
                                     'attempting to bind on address '
-                                    '{!r}: {}'.format(
+                                    '{0!r}: {1}'.format(
                                         laddr, exc.strerror.lower()))
                                 exceptions.append(exc)
                         else:
@@ -363,7 +363,7 @@ class BaseEventLoop(events.AbstractEventLoop):
                         raise exceptions[0]
                     # Raise a combined exception so the user can see all
                     # the various error messages.
-                    raise OSError('Multiple exceptions: {}'.format(
+                    raise OSError('Multiple exceptions: {0}'.format(
                         ', '.join(str(exc) for exc in exceptions)))
 
         elif sock is None:
@@ -615,7 +615,7 @@ class BaseEventLoop(events.AbstractEventLoop):
         t0 = self.time()
         event_list = self._selector.select(timeout)
         t1 = self.time()
-        argstr = '' if timeout is None else ' {:.3f}'.format(timeout)
+        argstr = '' if timeout is None else ' {0:.3f}'.format(timeout)
         if t1-t0 >= 1:
             level = logging.INFO
         else:

asyncio/events.py

@@ -25,7 +25,7 @@ class Handle(object):
         self._cancelled = False
 
     def __repr__(self):
-        res = 'Handle({}, {})'.format(self._callback, self._args)
+        res = 'Handle({0}, {1})'.format(self._callback, self._args)
         if self._cancelled:
             res += '<cancelled>'
         return res
@@ -58,9 +58,9 @@ class TimerHandle(Handle):
         self._when = when
 
     def __repr__(self):
-        res = 'TimerHandle({}, {}, {})'.format(self._when,
+        res = 'TimerHandle({0}, {1}, {2})'.format(self._when,
-                                               self._callback,
+                                                  self._callback,
-                                               self._args)
+                                                  self._args)
         if self._cancelled:
             res += '<cancelled>'
 

asyncio/futures.py

@@ -152,19 +152,19 @@ class Future(object):
         res = self.__class__.__name__
         if self._state == _FINISHED:
             if self._exception is not None:
-                res += '<exception={!r}>'.format(self._exception)
+                res += '<exception={0!r}>'.format(self._exception)
             else:
-                res += '<result={!r}>'.format(self._result)
+                res += '<result={0!r}>'.format(self._result)
         elif self._callbacks:
             size = len(self._callbacks)
             if size > 2:
-                res += '<{}, [{}, <{} more>, {}]>'.format(
+                res += '<{0}, [{1}, <{2} more>, {3}]>'.format(
                     self._state, self._callbacks[0],
                     size-2, self._callbacks[-1])
             else:
-                res += '<{}, {}>'.format(self._state, self._callbacks)
+                res += '<{0}, {1}>'.format(self._state, self._callbacks)
         else:
-            res += '<{}>'.format(self._state)
+            res += '<{0}>'.format(self._state)
         return res
 
     def cancel(self):
@@ -277,7 +277,7 @@ class Future(object):
         InvalidStateError.
         """
         if self._state != _PENDING:
-            raise InvalidStateError('{}: {!r}'.format(self._state, self))
+            raise InvalidStateError('{0}: {1!r}'.format(self._state, self))
         self._result = result
         self._state = _FINISHED
         self._schedule_callbacks()
@@ -289,7 +289,7 @@ class Future(object):
         InvalidStateError.
         """
         if self._state != _PENDING:
-            raise InvalidStateError('{}: {!r}'.format(self._state, self))
+            raise InvalidStateError('{0}: {1!r}'.format(self._state, self))
         self._exception = exception
 
         # FIXME: delay when the traceback is formatted
@@ -339,7 +339,7 @@ def wrap_future(fut, loop=None):
     if isinstance(fut, Future):
         return fut
     assert isinstance(fut, executor.Future), \
-        'concurrent.futures.Future is expected, got {!r}'.format(fut)
+        'concurrent.futures.Future is expected, got {0!r}'.format(fut)
     if loop is None:
         loop = events.get_event_loop()
     new_future = Future(loop=loop)

asyncio/locks.py

@@ -75,8 +75,8 @@ class Lock(object):
         res = super(Lock, self).__repr__()
         extra = 'locked' if self._locked else 'unlocked'
         if self._waiters:
-            extra = '{},waiters:{}'.format(extra, len(self._waiters))
+            extra = '{0},waiters:{1}'.format(extra, len(self._waiters))
-        return '<{} [{}]>'.format(res[1:-1], extra)
+        return '<{0} [{1}]>'.format(res[1:-1], extra)
 
     def locked(self):
         """Return True if lock is acquired."""
@@ -159,8 +159,8 @@ class Event(object):
         res = super(Event, self).__repr__()
         extra = 'set' if self._value else 'unset'
         if self._waiters:
-            extra = '{},waiters:{}'.format(extra, len(self._waiters))
+            extra = '{0},waiters:{1}'.format(extra, len(self._waiters))
-        return '<{} [{}]>'.format(res[1:-1], extra)
+        return '<{0} [{1}]>'.format(res[1:-1], extra)
 
     def is_set(self):
         """Return True if and only if the internal flag is true."""
@@ -234,8 +234,8 @@ class Condition(object):
         res = super(Condition, self).__repr__()
         extra = 'locked' if self.locked() else 'unlocked'
         if self._waiters:
-            extra = '{},waiters:{}'.format(extra, len(self._waiters))
+            extra = '{0},waiters:{1}'.format(extra, len(self._waiters))
-        return '<{} [{}]>'.format(res[1:-1], extra)
+        return '<{0} [{1}]>'.format(res[1:-1], extra)
 
     @tasks.coroutine
     def wait(self):
@@ -356,11 +356,11 @@ class Semaphore(object):
 
     def __repr__(self):
         res = super(Semaphore, self).__repr__()
-        extra = 'locked' if self._locked else 'unlocked,value:{}'.format(
+        extra = 'locked' if self._locked else 'unlocked,value:{0}'.format(
             self._value)
         if self._waiters:
-            extra = '{},waiters:{}'.format(extra, len(self._waiters))
+            extra = '{0},waiters:{1}'.format(extra, len(self._waiters))
-        return '<{} [{}]>'.format(res[1:-1], extra)
+        return '<{0} [{1}]>'.format(res[1:-1], extra)
 
     def locked(self):
         """Returns True if semaphore can not be acquired immediately."""

asyncio/queues.py

@@ -53,20 +53,20 @@ class Queue(object):
         self._queue.append(item)
 
     def __repr__(self):
-        return '<{} at {:#x} {}>'.format(
+        return '<{0} at {1:#x} {2}>'.format(
             type(self).__name__, id(self), self._format())
 
     def __str__(self):
-        return '<{} {}>'.format(type(self).__name__, self._format())
+        return '<{0} {1}>'.format(type(self).__name__, self._format())
 
     def _format(self):
-        result = 'maxsize={!r}'.format(self._maxsize)
+        result = 'maxsize={0!r}'.format(self._maxsize)
         if getattr(self, '_queue', None):
-            result += ' _queue={!r}'.format(list(self._queue))
+            result += ' _queue={0!r}'.format(list(self._queue))
         if self._getters:
-            result += ' _getters[{}]'.format(len(self._getters))
+            result += ' _getters[{0}]'.format(len(self._getters))
         if self._putters:
-            result += ' _putters[{}]'.format(len(self._putters))
+            result += ' _putters[{0}]'.format(len(self._putters))
         return result
 
     def _consume_done_getters(self):
@@ -244,7 +244,7 @@ class JoinableQueue(Queue):
     def _format(self):
         result = Queue._format(self)
         if self._unfinished_tasks:
-            result += ' tasks={}'.format(self._unfinished_tasks)
+            result += ' tasks={0}'.format(self._unfinished_tasks)
         return result
 
     def _put(self, item):

asyncio/selectors.py

@@ -37,9 +37,9 @@ def _fileobj_to_fd(fileobj):
             fd = int(fileobj.fileno())
         except (AttributeError, TypeError, ValueError):
             raise ValueError("Invalid file object: "
-                             "{!r}".format(fileobj))
+                             "{0!r}".format(fileobj))
     if fd < 0:
-        raise ValueError("Invalid file descriptor: {}".format(fd))
+        raise ValueError("Invalid file descriptor: {0}".format(fd))
     return fd
 
 
@@ -62,7 +62,7 @@ class _SelectorMapping(Mapping):
             fd = self._selector._fileobj_lookup(fileobj)
             return self._selector._fd_to_key[fd]
         except KeyError:
-            raise KeyError("{!r} is not registered".format(fileobj))
+            raise KeyError("{0!r} is not registered".format(fileobj))
 
     def __iter__(self):
         return iter(self._selector._fd_to_key)
@@ -179,7 +179,7 @@ class BaseSelector(object):
         try:
             return mapping[fileobj]
         except KeyError:
-            raise KeyError("{!r} is not registered".format(fileobj))
+            raise KeyError("{0!r} is not registered".format(fileobj))
 
     @abstractmethod
     def get_map(self):
@@ -223,12 +223,12 @@ class _BaseSelectorImpl(BaseSelector):
 
     def register(self, fileobj, events, data=None):
         if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
-            raise ValueError("Invalid events: {!r}".format(events))
+            raise ValueError("Invalid events: {0!r}".format(events))
 
         key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
 
         if key.fd in self._fd_to_key:
-            raise KeyError("{!r} (FD {}) is already registered"
+            raise KeyError("{0!r} (FD {1}) is already registered"
                            .format(fileobj, key.fd))
 
         self._fd_to_key[key.fd] = key
@@ -238,7 +238,7 @@ class _BaseSelectorImpl(BaseSelector):
         try:
             key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
         except KeyError:
-            raise KeyError("{!r} is not registered".format(fileobj))
+            raise KeyError("{0!r} is not registered".format(fileobj))
         return key
 
     def modify(self, fileobj, events, data=None):
@@ -246,7 +246,7 @@ class _BaseSelectorImpl(BaseSelector):
         try:
             key = self._fd_to_key[self._fileobj_lookup(fileobj)]
         except KeyError:
-            raise KeyError("{!r} is not registered".format(fileobj))
+            raise KeyError("{0!r} is not registered".format(fileobj))
         if events != key.events:
             self.unregister(fileobj)
             key = self.register(fileobj, events, data)

asyncio/tasks.py

@@ -93,7 +93,7 @@ class Task(futures.Future):
         i = res.find('<')
         if i < 0:
             i = len(res)
-        res = res[:i] + '(<{}>)'.format(self._coro.__name__) + res[i:]
+        res = res[:i] + '(<{0}>)'.format(self._coro.__name__) + res[i:]
         return res
 
     def get_stack(self, limit=None):
@@ -188,7 +188,7 @@ class Task(futures.Future):
 
     def _step(self, value=None, exc=None):
         assert not self.done(), \
-            '_step(): already done: {!r}, {!r}, {!r}'.format(self, value, exc)
+            '_step(): already done: {0!r}, {1!r}, {2!r}'.format(self, value, exc)
         if self._must_cancel:
             if not isinstance(exc, futures.CancelledError):
                 exc = futures.CancelledError()
@@ -235,7 +235,7 @@ class Task(futures.Future):
                 self._loop.call_soon(
                     self._step, None,
                     RuntimeError(
-                        'Task got bad yield: {!r}'.format(result)))
+                        'Task got bad yield: {0!r}'.format(result)))
         finally:
             self.__class__._current_tasks.pop(self._loop)
         self = None
@@ -283,7 +283,7 @@ def wait(fs, loop=None, timeout=None, return_when=ALL_COMPLETED):
     fs = set(async(f, loop=loop) for f in fs)
 
     if return_when not in (FIRST_COMPLETED, FIRST_EXCEPTION, ALL_COMPLETED):
-        raise ValueError('Invalid return_when value: {}'.format(return_when))
+        raise ValueError('Invalid return_when value: {0}'.format(return_when))
     result = yield _wait(fs, timeout, return_when, loop)
     raise Return(result)
 

asyncio/test_utils.py

@@ -228,11 +228,11 @@ class TestLoop(base_events.BaseEventLoop):
             return False
 
     def assert_reader(self, fd, callback, *args):
-        assert fd in self.readers, 'fd {} is not registered'.format(fd)
+        assert fd in self.readers, 'fd {0} is not registered'.format(fd)
         handle = self.readers[fd]
-        assert handle._callback == callback, '{!r} != {!r}'.format(
+        assert handle._callback == callback, '{0!r} != {1!r}'.format(
             handle._callback, callback)
-        assert handle._args == args, '{!r} != {!r}'.format(
+        assert handle._args == args, '{0!r} != {1!r}'.format(
             handle._args, args)
 
     def add_writer(self, fd, callback, *args):
@@ -247,11 +247,11 @@ class TestLoop(base_events.BaseEventLoop):
             return False
 
     def assert_writer(self, fd, callback, *args):
-        assert fd in self.writers, 'fd {} is not registered'.format(fd)
+        assert fd in self.writers, 'fd {0} is not registered'.format(fd)
         handle = self.writers[fd]
-        assert handle._callback == callback, '{!r} != {!r}'.format(
+        assert handle._callback == callback, '{0!r} != {1!r}'.format(
             handle._callback, callback)
-        assert handle._args == args, '{!r} != {!r}'.format(
+        assert handle._args == args, '{0!r} != {1!r}'.format(
             handle._args, args)
 
     def reset_counters(self):

asyncio/unix_events.py

@@ -91,7 +91,7 @@ class _UnixSelectorEventLoop(selector_events.BaseSelectorEventLoop):
                     logger.info('set_wakeup_fd(-1) failed: %s', nexc)
 
             if isinstance(exc, RuntimeError) or exc.errno == errno.EINVAL:
-                raise RuntimeError('sig {} cannot be caught'.format(sig))
+                raise RuntimeError('sig {0} cannot be caught'.format(sig))
             else:
                 raise exc_type, exc_value, tb
 
@@ -125,7 +125,7 @@ class _UnixSelectorEventLoop(selector_events.BaseSelectorEventLoop):
             signal.signal(sig, handler)
         except OSError as exc:
             if exc.errno == errno.EINVAL:
-                raise RuntimeError('sig {} cannot be caught'.format(sig))
+                raise RuntimeError('sig {0} cannot be caught'.format(sig))
             else:
                 raise
 
@@ -144,11 +144,11 @@ class _UnixSelectorEventLoop(selector_events.BaseSelectorEventLoop):
         Raise RuntimeError if there is a problem setting up the handler.
         """
         if not isinstance(sig, int):
-            raise TypeError('sig must be an int, not {!r}'.format(sig))
+            raise TypeError('sig must be an int, not {0!r}'.format(sig))
 
         if not (1 <= sig < signal.NSIG):
             raise ValueError(
-                'sig {} out of range(1, {})'.format(sig, signal.NSIG))
+                'sig {0} out of range(1, {1})'.format(sig, signal.NSIG))
 
     def _make_read_pipe_transport(self, pipe, protocol, waiter=None,
                                   extra=None):

check.py

@@ -37,7 +37,7 @@ def process(fn):
             line = line.rstrip('\n')
             sline = line.rstrip()
             if len(line) >= 80 or line != sline or not isascii(line):
-                print('{}:{:d}:{}{}'.format(
+                print('{0}:{1:d}:{2}{3}'.format(
                     fn, i+1, sline, '_' * (len(line) - len(sline))))
     finally:
         f.close()

examples/cachesvr.py

@@ -166,7 +166,7 @@ class Cache:
                 break
             response_b = json.dumps(response).encode('utf8') + b'\r\n'
             byte_count = len(response_b)
-            framing_s = 'response {} {}\r\n'.format(request_id, byte_count)
+            framing_s = 'response {0} {1}\r\n'.format(request_id, byte_count)
             writer.write(framing_s.encode('ascii'))
             yield from asyncio.sleep(args.resp_sleep*random.random(),
                                      loop=self.loop)

examples/simple_tcp_server.py

@@ -75,7 +75,7 @@ class MyServer:
                 msg = args[1]
                 client_writer.write("begin\n".encode("utf-8"))
                 for idx in range(times):
-                    client_writer.write("{}. {}\n".format(idx+1, msg)
+                    client_writer.write("{0}. {1}\n".format(idx+1, msg)
                                         .encode("utf-8"))
                 client_writer.write("end\n".encode("utf-8"))
             else:

examples/timing_tcp_server.py

@@ -78,7 +78,7 @@ class MyServer:
                 msg = args[1]
                 client_writer.write("begin\n".encode("utf-8"))
                 for idx in range(times):
-                    client_writer.write("{}. {}\n".format(
+                    client_writer.write("{0}. {1}\n".format(
                         idx+1, msg + 'x'*random.randint(10, 50))
                                         .encode("utf-8"))
                 client_writer.write("end\n".encode("utf-8"))
@@ -143,7 +143,7 @@ def main():
 
         for N in Ns:
             t0 = time.time()
-            send("repeat {} hello world ".format(N))
+            send("repeat {0} hello world ".format(N))
             msg = yield recv()
             assert msg == 'begin'
             while True:
@@ -152,7 +152,7 @@ def main():
                     break
             t1 = time.time()
             dt = t1 - t0
-            print("Time taken: {:.3f} seconds ({:.6f} per repetition)"
+            print("Time taken: {0:.3f} seconds ({1:.6f} per repetition)"
                   .format(dt, dt/N))
             times.append(dt)
 

examples/udp_echo.py

@@ -32,12 +32,12 @@ class MyClientUdpEchoProtocol:
 
     def connection_made(self, transport):
         self.transport = transport
-        print('sending "{}"'.format(self.message))
+        print('sending "{0}"'.format(self.message))
         self.transport.sendto(self.message.encode())
         print('waiting to receive')
 
     def datagram_received(self, data, addr):
-        print('received "{}"'.format(data.decode()))
+        print('received "{0}"'.format(data.decode()))
         self.transport.close()
 
     def error_received(self, exc):

runtests.py

@@ -81,20 +81,20 @@ def load_modules(basedir, suffix='.py'):
         modpath = os.path.join(dir, '__init__.py')
         if os.path.isfile(modpath):
             mod = os.path.split(dir)[-1]
-            files.append(('{}{}'.format(prefix, mod), modpath))
+            files.append(('{0}{1}'.format(prefix, mod), modpath))
 
-            prefix = '{}{}.'.format(prefix, mod)
+            prefix = '{0}{1}.'.format(prefix, mod)
 
         for name in os.listdir(dir):
             path = os.path.join(dir, name)
 
             if os.path.isdir(path):
-                files.extend(list_dir('{}{}.'.format(prefix, name), path))
+                files.extend(list_dir('{0}{1}.'.format(prefix, name), path))
             else:
                 if (name != '__init__.py' and
                     name.endswith(suffix) and
                     not name.startswith(('.', '_'))):
-                    files.append(('{}{}'.format(prefix, name[:-3]), path))
+                    files.append(('{0}{1}'.format(prefix, name[:-3]), path))
 
         return files
 
@@ -108,7 +108,7 @@ def load_modules(basedir, suffix='.py'):
         except SyntaxError:
             raise
         except Exception as err:
-            print("Skipping '{}': {}".format(modname, err), file=sys.stderr)
+            print("Skipping '{0}': {1}".format(modname, err), file=sys.stderr)
 
     return mods
 
@@ -185,7 +185,7 @@ class TestRunner(unittest.TextTestRunner):
     def run(self, test):
         result = super().run(test)
         if result.leaks:
-            self.stream.writeln("{} tests leaks:".format(len(result.leaks)))
+            self.stream.writeln("{0} tests leaks:".format(len(result.leaks)))
             for name, leaks in result.leaks:
                 self.stream.writeln(' '*4 + name + ':')
                 for leak in leaks:
@@ -214,7 +214,7 @@ def runtests():
 
     testsdir = os.path.abspath(args.testsdir)
     if not os.path.isdir(testsdir):
-        print("Tests directory is not found: {}\n".format(testsdir))
+        print("Tests directory is not found: {0}\n".format(testsdir))
         ARGS.print_help()
         return
 
@@ -272,7 +272,7 @@ def runtests():
             cov.report(show_missing=False)
             here = os.path.dirname(os.path.abspath(__file__))
             print("\nFor html report:")
-            print("open file://{}/htmlcov/index.html".format(here))
+            print("open file://{0}/htmlcov/index.html".format(here))
 
 
 if __name__ == '__main__':

tests/test_windows_events.py

@@ -84,11 +84,11 @@ class ProactorTests(unittest.TestCase):
             clients.append((stream_reader, trans))
 
         for i, (r, w) in enumerate(clients):
-            w.write('lower-{}\n'.format(i).encode())
+            w.write('lower-{0}\n'.format(i).encode())
 
         for i, (r, w) in enumerate(clients):
             response = yield r.readline()
-            self.assertEqual(response, 'LOWER-{}\n'.format(i).encode())
+            self.assertEqual(response, 'LOWER-{0}\n'.format(i).encode())
             w.close()
 
         server.close()