refactor 1

Author: kumaraditya303

Lib/asyncio/selector_events.py

@@ -866,7 +866,7 @@ def close(self):
         if not self._buffer:
             self._conn_lost += 1
             self._loop._remove_writer(self._sock_fd)
-            self._loop.call_soon(self._call_connection_lost, None, context=self._context)
+            self._call_soon(self._call_connection_lost, None)
 
     def __del__(self, _warn=warnings.warn):
         if self._sock is not None:
@@ -899,7 +899,7 @@ def _force_close(self, exc):
             self._closing = True
             self._loop._remove_reader(self._sock_fd)
         self._conn_lost += 1
-        self._loop.call_soon(self._call_connection_lost, exc, context=self._context)
+        self._call_soon(self._call_connection_lost, exc)
 
     def _call_connection_lost(self, exc):
         try:
@@ -923,6 +923,11 @@ def _add_reader(self, fd, callback, *args):
             return
         self._loop._add_reader(fd, callback, *args, context=self._context)
 
+    def _add_writer(self, fd, callback, *args):
+        self._loop._add_writer(fd, callback, *args, context=self._context)
+
+    def _call_soon(self, callback, *args):
+        self._loop.call_soon(callback, *args, context=self._context)
 
 class _SelectorSocketTransport(_SelectorTransport):
 
@@ -945,14 +950,12 @@ def __init__(self, loop, sock, protocol, waiter=None,
         # decreases the latency (in some cases significantly.)
         base_events._set_nodelay(self._sock)
 
-        self._loop.call_soon(self._protocol.connection_made, self, context=context)
+        self._call_soon(self._protocol.connection_made, self)
         # only start reading when connection_made() has been called
-        self._loop.call_soon(self._add_reader,
-                             self._sock_fd, self._read_ready, context=context)
+        self._call_soon(self._add_reader, self._sock_fd, self._read_ready)
         if waiter is not None:
             # only wake up the waiter when connection_made() has been called
-            self._loop.call_soon(futures._set_result_unless_cancelled,
-                                 waiter, None, context=context)
+            self._call_soon(futures._set_result_unless_cancelled, waiter, None)
 
     def set_protocol(self, protocol):
         if isinstance(protocol, protocols.BufferedProtocol):
@@ -1081,7 +1084,7 @@ def write(self, data):
                 if not data:
                     return
             # Not all was written; register write handler.
-            self._loop._add_writer(self._sock_fd, self._write_ready, context=self._context)
+            self._add_writer(self._sock_fd, self._write_ready)
 
         # Add it to the buffer.
         self._buffer.append(data)
@@ -1185,7 +1188,7 @@ def writelines(self, list_of_data):
         self._write_ready()
         # If the entire buffer couldn't be written, register a write handler
         if self._buffer:
-            self._loop._add_writer(self._sock_fd, self._write_ready, context=self._context)
+            self._add_writer(self._sock_fd, self._write_ready)
             self._maybe_pause_protocol()
 
     def can_write_eof(self):
@@ -1226,14 +1229,12 @@ def __init__(self, loop, sock, protocol, address=None,
         super().__init__(loop, sock, protocol, extra)
         self._address = address
         self._buffer_size = 0
-        self._loop.call_soon(self._protocol.connection_made, self)
+        self._call_soon(self._protocol.connection_made, self)
         # only start reading when connection_made() has been called
-        self._loop.call_soon(self._add_reader,
-                             self._sock_fd, self._read_ready)
+        self._call_soon(self._add_reader, self._sock_fd, self._read_ready)
         if waiter is not None:
             # only wake up the waiter when connection_made() has been called
-            self._loop.call_soon(futures._set_result_unless_cancelled,
-                                 waiter, None)
+            self._call_soon(futures._set_result_unless_cancelled, waiter, None)
 
     def get_write_buffer_size(self):
         return self._buffer_size
@@ -1280,7 +1281,7 @@ def sendto(self, data, addr=None):
                     self._sock.sendto(data, addr)
                 return
             except (BlockingIOError, InterruptedError):
-                self._loop._add_writer(self._sock_fd, self._sendto_ready)
+                self._add_writer(self._sock_fd, self._sendto_ready)
             except OSError as exc:
                 self._protocol.error_received(exc)
                 return