Merge weirdness in uninterpolate branch.

12 files changed, 34 insertions, 32 deletions

diff --git a/tests/selector_events_test.py b/tests/selector_events_test.py
index 4836008..82b7811 100644
--- a/tests/selector_events_test.py
+++ b/tests/selector_events_test.py
@@ -788,7 +788,7 @@ class SelectorSocketTransportTests(unittest.TestCase):
         self.event_loop.remove_reader.assert_called_with(7)
         self.event_loop.remove_writer.assert_called_with(7)
         self.protocol.connection_lost.assert_called_with(exc)
-        m_exc.assert_called_with('Fatal error for %s', transport)
+        m_exc.assert_called_with('Fatal error for {}'.format(transport))
 
     def test_connection_lost(self):
         exc = object()
@@ -885,7 +885,7 @@ class SelectorSslTransportTests(unittest.TestCase):
         self.assertTrue(self.event_loop.remove_writer.called)
         self.assertTrue(self.event_loop.remove_reader.called)
         self.protocol.connection_lost.assert_called_with(exc)
-        m_exc.assert_called_with('Fatal error for %s', self.transport)
+        m_exc.assert_called_with('Fatal error for {}'.format(self.transport))
 
     def test_close(self):
         self.transport.close()
@@ -1265,7 +1265,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
         self.event_loop.remove_writer.assert_called_with(7)
         self.event_loop.remove_reader.assert_called_with(7)
         self.protocol.connection_lost.assert_called_with(exc)
-        m_exc.assert_called_with('Fatal error for %s', transport)
+        m_exc.assert_called_with('Fatal error for {}'.format(transport))
 
     @unittest.mock.patch('logging.exception')
     def test_fatal_error_connected(self, m_exc):
@@ -1274,7 +1274,7 @@ class SelectorDatagramTransportTests(unittest.TestCase):
         err = ConnectionRefusedError()
         transport._fatal_error(err)
         self.protocol.connection_refused.assert_called_with(err)
-        m_exc.assert_called_with('Fatal error for %s', transport)
+        m_exc.assert_called_with('Fatal error for {}'.format(transport))
 
     def test_transport_closing(self):
         exc = object()
diff --git a/tests/subprocess_test.py b/tests/subprocess_test.py
index 09aaed5..f3b745e 100644
--- a/tests/subprocess_test.py
+++ b/tests/subprocess_test.py
@@ -21,7 +21,7 @@ class MyProto(protocols.Protocol):
         transport.write_eof()
 
     def data_received(self, data):
-        logging.info('received: %r', data)
+        logging.info('received: {!r}'.format(data))
         assert self.state == 'CONNECTED', self.state
         self.nbytes += len(data)
 
diff --git a/tests/tasks_test.py b/tests/tasks_test.py
index 88c23b5..a02ca71 100644
--- a/tests/tasks_test.py
+++ b/tests/tasks_test.py
@@ -449,8 +449,8 @@ class TaskTests(test_utils.LogTrackingTestCase):
         task.set_result('ok')
 
         task._step()
-        self.assertTrue(m_logging.warn.called)
-        self.assertTrue(m_logging.warn.call_args[0][0].startswith(
+        self.assertTrue(m_logging.warning.called)
+        self.assertTrue(m_logging.warning.call_args[0][0].startswith(
             '_step(): already done: '))
 
     @unittest.mock.patch('tulip.tasks.logging')
@@ -462,14 +462,14 @@ class TaskTests(test_utils.LogTrackingTestCase):
 
         task = tasks.Task(notmuch())
         task._step()
-        self.assertFalse(m_logging.warn.called)
+        self.assertFalse(m_logging.warning.called)
 
         task._step()
-        self.assertTrue(m_logging.warn.called)
+        self.assertTrue(m_logging.warning.called)
         self.assertEqual(
-            '_step(): bad yield: %r',
-            m_logging.warn.call_args[0][0])
-        self.assertEqual(1, m_logging.warn.call_args[0][1])
+            '_step(): bad yield: {!r}',
+            m_logging.warning.call_args[0][0])
+        self.assertEqual(1, m_logging.warning.call_args[0][1])
 
     def test_step_result_future(self):
         # If coroutine returns future, task waits on this future.
diff --git a/tests/unix_events_test.py b/tests/unix_events_test.py
index ce250fd..ce6a2c8 100644
--- a/tests/unix_events_test.py
+++ b/tests/unix_events_test.py
@@ -242,7 +242,7 @@ class UnixReadPipeTransportTests(unittest.TestCase):
 
         m_read.assert_called_with(5, tr.max_size)
         tr._close.assert_called_with(err)
-        m_logexc.assert_called_with('Fatal error for %s', tr)
+        m_logexc.assert_called_with('Fatal error for {}'.format(tr))
 
     @unittest.mock.patch('os.read')
     @unittest.mock.patch('fcntl.fcntl')
@@ -484,7 +484,7 @@ class UnixWritePipeTransportTests(unittest.TestCase):
         self.assertEqual([], tr._buffer)
         self.assertTrue(tr._closing)
         self.protocol.connection_lost.assert_called_with(err)
-        m_logexc.assert_called_with('Fatal error for %s', tr)
+        m_logexc.assert_called_with('Fatal error for {}'.format(tr))
 
     @unittest.mock.patch('os.write')
     @unittest.mock.patch('fcntl.fcntl')
diff --git a/tulip/base_events.py b/tulip/base_events.py
index 127530f..16ffb5c 100644
--- a/tulip/base_events.py
+++ b/tulip/base_events.py
@@ -522,7 +522,8 @@ class BaseEventLoop(events.AbstractEventLoop):
             level = logging.INFO
         else:
             level = logging.DEBUG
-        logging.log(level, 'poll%s took %.3f seconds', argstr, t1-t0)
+        logging.log(
+            level, 'poll{} took {:.3f} seconds'.format(argstr, t1 - t0))
         self._process_events(event_list)
 
         # Handle 'later' callbacks that are ready.
diff --git a/tulip/events.py b/tulip/events.py
index ba9a50f..24eba7b 100644
--- a/tulip/events.py
+++ b/tulip/events.py
@@ -48,8 +48,8 @@ class Handle:
         try:
             self._callback(*self._args)
         except Exception:
-            logging.exception('Exception in callback %s %r',
-                              self._callback, self._args)
+            logging.exception('Exception in callback {} {!r}'.format(
+                self._callback, self._args))
 
 
 def make_handle(callback, args):
diff --git a/tulip/proactor_events.py b/tulip/proactor_events.py
index a43b640..045059b 100644
--- a/tulip/proactor_events.py
+++ b/tulip/proactor_events.py
@@ -91,7 +91,7 @@ class _ProactorSocketTransport(transports.Transport):
             self._event_loop.call_soon(self._call_connection_lost, None)
 
     def _fatal_error(self, exc):
-        logging.exception('Fatal error for %s', self)
+        logging.exception('Fatal error for {}'.format(self))
         if self._write_fut:
             self._write_fut.cancel()
         if self._read_fut:            # XXX
@@ -111,7 +111,7 @@ class BaseProactorEventLoop(base_events.BaseEventLoop):
 
     def __init__(self, proactor):
         super().__init__()
-        logging.debug('Using proactor: %s', proactor.__class__.__name__)
+        logging.debug('Using proactor: {}'.format(proactor.__class__.__name__))
         self._proactor = proactor
         self._selector = proactor   # convenient alias
         self._make_self_pipe()
diff --git a/tulip/selector_events.py b/tulip/selector_events.py
index 46e04da..fe92561 100644
--- a/tulip/selector_events.py
+++ b/tulip/selector_events.py
@@ -41,7 +41,7 @@ class BaseSelectorEventLoop(base_events.BaseEventLoop):
 
         if selector is None:
             selector = selectors.Selector()
-        logging.debug('Using selector: %s', selector.__class__.__name__)
+        logging.debug('Using selector: {}'.format(selector.__class__.__name__))
         self._selector = selector
         self._make_self_pipe()
 
@@ -396,7 +396,7 @@ class _SelectorSocketTransport(transports.Transport):
 
     def _fatal_error(self, exc):
         # should be called from exception handler only
-        logging.exception('Fatal error for %s', self)
+        logging.exception('Fatal error for {}'.format(self))
         self._close(exc)
 
     def _close(self, exc):
@@ -537,7 +537,7 @@ class _SelectorSslTransport(transports.Transport):
             self._protocol.connection_lost(None)
 
     def _fatal_error(self, exc):
-        logging.exception('Fatal error for %s', self)
+        logging.exception('Fatal error for {}'.format(self))
         self._close(exc)
 
     def _close(self, exc):
@@ -637,7 +637,7 @@ class _SelectorDatagramTransport(transports.DatagramTransport):
             self._call_connection_lost(None)
 
     def _fatal_error(self, exc):
-        logging.exception('Fatal error for %s', self)
+        logging.exception('Fatal error for {}'.format(self))
         self._close(exc)
 
     def _close(self, exc):
diff --git a/tulip/selectors.py b/tulip/selectors.py
index e8fd12e..3e1546b 100644
--- a/tulip/selectors.py
+++ b/tulip/selectors.py
@@ -196,7 +196,7 @@ class _BaseSelector:
         try:
             return self._fd_to_key[fd]
         except KeyError:
-            logging.warn('No key found for fd %r', fd)
+            logging.warning('No key found for fd {!r}'.format(fd))
             return None
 
 
diff --git a/tulip/subprocess_transport.py b/tulip/subprocess_transport.py
index 8d760f5..d101c88 100644
--- a/tulip/subprocess_transport.py
+++ b/tulip/subprocess_transport.py
@@ -85,7 +85,7 @@ class UnixSubprocessTransport(transports.Transport):
         # XXX What else?
 
     def _fatal_error(self, exc):
-        logging.error('Fatal error: %r', exc)
+        logging.error('Fatal error: {!r}'.format(exc))
         if self._rstdout >= 0:
             os.close(self._rstdout)
             self._rstdout = -1
diff --git a/tulip/tasks.py b/tulip/tasks.py
index 5d3d289..ec1775a 100644
--- a/tulip/tasks.py
+++ b/tulip/tasks.py
@@ -26,7 +26,7 @@ def coroutine(func):
         coro = func
     else:
         logging.warning(
-            'Coroutine function %s is not a generator.', func.__name__)
+            'Coroutine function {} is not a generator.'.format(func.__name__))
 
         @functools.wraps(func)
         def coro(*args, **kw):
@@ -102,7 +102,8 @@ class Task(futures.Future):
 
     def _step(self, value=None, exc=None):
         if self.done():
-            logging.warn('_step(): already done: %r, %r, %r', self, value, exc)
+            logging.warning('_step(): already done: {!r}, {!r}, {!r}'.format(
+                self, value, exc))
             return
         # We'll call either coro.throw(exc) or coro.send(value).
         if self._must_cancel:
@@ -163,7 +164,7 @@ class Task(futures.Future):
                                 self, result)))
                 else:
                     if result is not None:
-                        logging.warn('_step(): bad yield: %r', result)
+                        logging.warning('_step(): bad yield: {!r}', result)
 
                     self._event_loop.call_soon(self._step)
 
diff --git a/tulip/unix_events.py b/tulip/unix_events.py
index 9e75e3e..208acec 100644
--- a/tulip/unix_events.py
+++ b/tulip/unix_events.py
@@ -64,7 +64,7 @@ class SelectorEventLoop(selector_events.BaseSelectorEventLoop):
                 try:
                     signal.set_wakeup_fd(-1)
                 except ValueError as nexc:
-                    logging.info('set_wakeup_fd(-1) failed: %s', nexc)
+                    logging.info('set_wakeup_fd(-1) failed: {}'.format(nexc))
 
             if exc.errno == errno.EINVAL:
                 raise RuntimeError('sig {} cannot be caught'.format(sig))
@@ -110,7 +110,7 @@ class SelectorEventLoop(selector_events.BaseSelectorEventLoop):
             try:
                 signal.set_wakeup_fd(-1)
             except ValueError as exc:
-                logging.info('set_wakeup_fd(-1) failed: %s', exc)
+                logging.info('set_wakeup_fd(-1) failed: {}'.format(exc))
 
         return True
 
@@ -189,7 +189,7 @@ class _UnixReadPipeTransport(transports.ReadTransport):
 
     def _fatal_error(self, exc):
         # should be called by exception handler only
-        logging.exception('Fatal error for %s', self)
+        logging.exception('Fatal error for {}'.format(self))
         self._close(exc)
 
     def _close(self, exc):
@@ -285,7 +285,7 @@ class _UnixWritePipeTransport(transports.WriteTransport):
 
     def _fatal_error(self, exc):
         # should be called by exception handler only
-        logging.exception('Fatal error for %s', self)
+        logging.exception('Fatal error for {}'.format(self))
         self._close(exc)
 
     def _close(self, exc=None):