Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 739 insertions, 739 deletions

diff --git a/contrib/tools/python3/src/Lib/socket.py b/contrib/tools/python3/src/Lib/socket.py
index 235c3f0677e..46fc49ca323 100644
--- a/contrib/tools/python3/src/Lib/socket.py
+++ b/contrib/tools/python3/src/Lib/socket.py
@@ -1,129 +1,129 @@
-# Wrapper module for _socket, providing some additional facilities 
-# implemented in Python. 
- 
-"""\ 
-This module provides socket operations and some related functions. 
-On Unix, it supports IP (Internet Protocol) and Unix domain sockets. 
-On other systems, it only supports IP. Functions specific for a 
-socket are available as methods of the socket object. 
- 
-Functions: 
- 
-socket() -- create a new socket object 
-socketpair() -- create a pair of new socket objects [*] 
-fromfd() -- create a socket object from an open file descriptor [*] 
+# Wrapper module for _socket, providing some additional facilities
+# implemented in Python.
+
+"""\
+This module provides socket operations and some related functions.
+On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
+On other systems, it only supports IP. Functions specific for a
+socket are available as methods of the socket object.
+
+Functions:
+
+socket() -- create a new socket object
+socketpair() -- create a pair of new socket objects [*]
+fromfd() -- create a socket object from an open file descriptor [*]
 send_fds() -- Send file descriptor to the socket.
 recv_fds() -- Recieve file descriptors from the socket.
-fromshare() -- create a socket object from data received from socket.share() [*] 
-gethostname() -- return the current hostname 
-gethostbyname() -- map a hostname to its IP number 
-gethostbyaddr() -- map an IP number or hostname to DNS info 
-getservbyname() -- map a service name and a protocol name to a port number 
-getprotobyname() -- map a protocol name (e.g. 'tcp') to a number 
-ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order 
-htons(), htonl() -- convert 16, 32 bit int from host to network byte order 
-inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format 
-inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89) 
-socket.getdefaulttimeout() -- get the default timeout value 
-socket.setdefaulttimeout() -- set the default timeout value 
-create_connection() -- connects to an address, with an optional timeout and 
-                       optional source address. 
- 
- [*] not available on all platforms! 
- 
-Special objects: 
- 
-SocketType -- type object for socket objects 
-error -- exception raised for I/O errors 
-has_ipv6 -- boolean value indicating if IPv6 is supported 
- 
-IntEnum constants: 
- 
-AF_INET, AF_UNIX -- socket domains (first argument to socket() call) 
-SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument) 
- 
-Integer constants: 
- 
-Many other constants may be defined; these may be used in calls to 
-the setsockopt() and getsockopt() methods. 
-""" 
- 
-import _socket 
-from _socket import * 
- 
-import os, sys, io, selectors 
-from enum import IntEnum, IntFlag 
- 
-try: 
-    import errno 
-except ImportError: 
-    errno = None 
-EBADF = getattr(errno, 'EBADF', 9) 
-EAGAIN = getattr(errno, 'EAGAIN', 11) 
-EWOULDBLOCK = getattr(errno, 'EWOULDBLOCK', 11) 
- 
+fromshare() -- create a socket object from data received from socket.share() [*]
+gethostname() -- return the current hostname
+gethostbyname() -- map a hostname to its IP number
+gethostbyaddr() -- map an IP number or hostname to DNS info
+getservbyname() -- map a service name and a protocol name to a port number
+getprotobyname() -- map a protocol name (e.g. 'tcp') to a number
+ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
+htons(), htonl() -- convert 16, 32 bit int from host to network byte order
+inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
+inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
+socket.getdefaulttimeout() -- get the default timeout value
+socket.setdefaulttimeout() -- set the default timeout value
+create_connection() -- connects to an address, with an optional timeout and
+                       optional source address.
+
+ [*] not available on all platforms!
+
+Special objects:
+
+SocketType -- type object for socket objects
+error -- exception raised for I/O errors
+has_ipv6 -- boolean value indicating if IPv6 is supported
+
+IntEnum constants:
+
+AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
+SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
+
+Integer constants:
+
+Many other constants may be defined; these may be used in calls to
+the setsockopt() and getsockopt() methods.
+"""
+
+import _socket
+from _socket import *
+
+import os, sys, io, selectors
+from enum import IntEnum, IntFlag
+
+try:
+    import errno
+except ImportError:
+    errno = None
+EBADF = getattr(errno, 'EBADF', 9)
+EAGAIN = getattr(errno, 'EAGAIN', 11)
+EWOULDBLOCK = getattr(errno, 'EWOULDBLOCK', 11)
+
 __all__ = ["fromfd", "getfqdn", "create_connection", "create_server",
            "has_dualstack_ipv6", "AddressFamily", "SocketKind"]
-__all__.extend(os._get_exports_list(_socket)) 
- 
-# Set up the socket.AF_* socket.SOCK_* constants as members of IntEnums for 
-# nicer string representations. 
-# Note that _socket only knows about the integer values. The public interface 
-# in this module understands the enums and translates them back from integers 
-# where needed (e.g. .family property of a socket object). 
- 
+__all__.extend(os._get_exports_list(_socket))
+
+# Set up the socket.AF_* socket.SOCK_* constants as members of IntEnums for
+# nicer string representations.
+# Note that _socket only knows about the integer values. The public interface
+# in this module understands the enums and translates them back from integers
+# where needed (e.g. .family property of a socket object).
+
 IntEnum._convert_(
-        'AddressFamily', 
-        __name__, 
-        lambda C: C.isupper() and C.startswith('AF_')) 
- 
+        'AddressFamily',
+        __name__,
+        lambda C: C.isupper() and C.startswith('AF_'))
+
 IntEnum._convert_(
-        'SocketKind', 
-        __name__, 
-        lambda C: C.isupper() and C.startswith('SOCK_')) 
- 
+        'SocketKind',
+        __name__,
+        lambda C: C.isupper() and C.startswith('SOCK_'))
+
 IntFlag._convert_(
-        'MsgFlag', 
-        __name__, 
-        lambda C: C.isupper() and C.startswith('MSG_')) 
- 
+        'MsgFlag',
+        __name__,
+        lambda C: C.isupper() and C.startswith('MSG_'))
+
 IntFlag._convert_(
-        'AddressInfo', 
-        __name__, 
-        lambda C: C.isupper() and C.startswith('AI_')) 
- 
-_LOCALHOST    = '127.0.0.1' 
-_LOCALHOST_V6 = '::1' 
- 
- 
-def _intenum_converter(value, enum_klass): 
-    """Convert a numeric family value to an IntEnum member. 
- 
-    If it's not a known member, return the numeric value itself. 
-    """ 
-    try: 
-        return enum_klass(value) 
-    except ValueError: 
-        return value 
- 
- 
-# WSA error codes 
-if sys.platform.lower().startswith("win"): 
-    errorTab = {} 
+        'AddressInfo',
+        __name__,
+        lambda C: C.isupper() and C.startswith('AI_'))
+
+_LOCALHOST    = '127.0.0.1'
+_LOCALHOST_V6 = '::1'
+
+
+def _intenum_converter(value, enum_klass):
+    """Convert a numeric family value to an IntEnum member.
+
+    If it's not a known member, return the numeric value itself.
+    """
+    try:
+        return enum_klass(value)
+    except ValueError:
+        return value
+
+
+# WSA error codes
+if sys.platform.lower().startswith("win"):
+    errorTab = {}
     errorTab[6] = "Specified event object handle is invalid."
     errorTab[8] = "Insufficient memory available."
     errorTab[87] = "One or more parameters are invalid."
     errorTab[995] = "Overlapped operation aborted."
     errorTab[996] = "Overlapped I/O event object not in signaled state."
     errorTab[997] = "Overlapped operation will complete later."
-    errorTab[10004] = "The operation was interrupted." 
-    errorTab[10009] = "A bad file handle was passed." 
-    errorTab[10013] = "Permission denied." 
+    errorTab[10004] = "The operation was interrupted."
+    errorTab[10009] = "A bad file handle was passed."
+    errorTab[10013] = "Permission denied."
     errorTab[10014] = "A fault occurred on the network??"  # WSAEFAULT
-    errorTab[10022] = "An invalid operation was attempted." 
+    errorTab[10022] = "An invalid operation was attempted."
     errorTab[10024] = "Too many open files."
-    errorTab[10035] = "The socket operation would block" 
-    errorTab[10036] = "A blocking operation is already in progress." 
+    errorTab[10035] = "The socket operation would block"
+    errorTab[10036] = "A blocking operation is already in progress."
     errorTab[10037] = "Operation already in progress."
     errorTab[10038] = "Socket operation on nonsocket."
     errorTab[10039] = "Destination address required."
@@ -135,24 +135,24 @@ if sys.platform.lower().startswith("win"):
     errorTab[10045] = "Operation not supported."
     errorTab[10046] = "Protocol family not supported."
     errorTab[10047] = "Address family not supported by protocol family."
-    errorTab[10048] = "The network address is in use." 
+    errorTab[10048] = "The network address is in use."
     errorTab[10049] = "Cannot assign requested address."
     errorTab[10050] = "Network is down."
     errorTab[10051] = "Network is unreachable."
     errorTab[10052] = "Network dropped connection on reset."
     errorTab[10053] = "Software caused connection abort."
-    errorTab[10054] = "The connection has been reset." 
+    errorTab[10054] = "The connection has been reset."
     errorTab[10055] = "No buffer space available."
     errorTab[10056] = "Socket is already connected."
     errorTab[10057] = "Socket is not connected."
-    errorTab[10058] = "The network has been shut down." 
+    errorTab[10058] = "The network has been shut down."
     errorTab[10059] = "Too many references."
-    errorTab[10060] = "The operation timed out." 
-    errorTab[10061] = "Connection refused." 
+    errorTab[10060] = "The operation timed out."
+    errorTab[10061] = "Connection refused."
     errorTab[10062] = "Cannot translate name."
-    errorTab[10063] = "The name is too long." 
-    errorTab[10064] = "The host is down." 
-    errorTab[10065] = "The host is unreachable." 
+    errorTab[10063] = "The name is too long."
+    errorTab[10064] = "The host is down."
+    errorTab[10065] = "The host is unreachable."
     errorTab[10066] = "Directory not empty."
     errorTab[10067] = "Too many processes."
     errorTab[10068] = "User quota exceeded."
@@ -205,345 +205,345 @@ if sys.platform.lower().startswith("win"):
     errorTab[11029] = "Invalid QoS shape discard mode object."
     errorTab[11030] = "Invalid QoS shaping rate object."
     errorTab[11031] = "Reserved policy QoS element type."
-    __all__.append("errorTab") 
- 
- 
-class _GiveupOnSendfile(Exception): pass 
- 
- 
-class socket(_socket.socket): 
- 
-    """A subclass of _socket.socket adding the makefile() method.""" 
- 
-    __slots__ = ["__weakref__", "_io_refs", "_closed"] 
- 
-    def __init__(self, family=-1, type=-1, proto=-1, fileno=None): 
-        # For user code address family and type values are IntEnum members, but 
-        # for the underlying _socket.socket they're just integers. The 
-        # constructor of _socket.socket converts the given argument to an 
-        # integer automatically. 
-        if fileno is None: 
-            if family == -1: 
-                family = AF_INET 
-            if type == -1: 
-                type = SOCK_STREAM 
-            if proto == -1: 
-                proto = 0 
-        _socket.socket.__init__(self, family, type, proto, fileno) 
-        self._io_refs = 0 
-        self._closed = False 
- 
-    def __enter__(self): 
-        return self 
- 
-    def __exit__(self, *args): 
-        if not self._closed: 
-            self.close() 
- 
-    def __repr__(self): 
-        """Wrap __repr__() to reveal the real class name and socket 
-        address(es). 
-        """ 
-        closed = getattr(self, '_closed', False) 
-        s = "<%s.%s%s fd=%i, family=%s, type=%s, proto=%i" \ 
-            % (self.__class__.__module__, 
-               self.__class__.__qualname__, 
-               " [closed]" if closed else "", 
-               self.fileno(), 
-               self.family, 
-               self.type, 
-               self.proto) 
-        if not closed: 
-            try: 
-                laddr = self.getsockname() 
-                if laddr: 
-                    s += ", laddr=%s" % str(laddr) 
-            except error: 
-                pass 
-            try: 
-                raddr = self.getpeername() 
-                if raddr: 
-                    s += ", raddr=%s" % str(raddr) 
-            except error: 
-                pass 
-        s += '>' 
-        return s 
- 
-    def __getstate__(self): 
+    __all__.append("errorTab")
+
+
+class _GiveupOnSendfile(Exception): pass
+
+
+class socket(_socket.socket):
+
+    """A subclass of _socket.socket adding the makefile() method."""
+
+    __slots__ = ["__weakref__", "_io_refs", "_closed"]
+
+    def __init__(self, family=-1, type=-1, proto=-1, fileno=None):
+        # For user code address family and type values are IntEnum members, but
+        # for the underlying _socket.socket they're just integers. The
+        # constructor of _socket.socket converts the given argument to an
+        # integer automatically.
+        if fileno is None:
+            if family == -1:
+                family = AF_INET
+            if type == -1:
+                type = SOCK_STREAM
+            if proto == -1:
+                proto = 0
+        _socket.socket.__init__(self, family, type, proto, fileno)
+        self._io_refs = 0
+        self._closed = False
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        if not self._closed:
+            self.close()
+
+    def __repr__(self):
+        """Wrap __repr__() to reveal the real class name and socket
+        address(es).
+        """
+        closed = getattr(self, '_closed', False)
+        s = "<%s.%s%s fd=%i, family=%s, type=%s, proto=%i" \
+            % (self.__class__.__module__,
+               self.__class__.__qualname__,
+               " [closed]" if closed else "",
+               self.fileno(),
+               self.family,
+               self.type,
+               self.proto)
+        if not closed:
+            try:
+                laddr = self.getsockname()
+                if laddr:
+                    s += ", laddr=%s" % str(laddr)
+            except error:
+                pass
+            try:
+                raddr = self.getpeername()
+                if raddr:
+                    s += ", raddr=%s" % str(raddr)
+            except error:
+                pass
+        s += '>'
+        return s
+
+    def __getstate__(self):
         raise TypeError(f"cannot pickle {self.__class__.__name__!r} object")
- 
-    def dup(self): 
-        """dup() -> socket object 
- 
-        Duplicate the socket. Return a new socket object connected to the same 
-        system resource. The new socket is non-inheritable. 
-        """ 
-        fd = dup(self.fileno()) 
-        sock = self.__class__(self.family, self.type, self.proto, fileno=fd) 
-        sock.settimeout(self.gettimeout()) 
-        return sock 
- 
-    def accept(self): 
-        """accept() -> (socket object, address info) 
- 
-        Wait for an incoming connection.  Return a new socket 
-        representing the connection, and the address of the client. 
-        For IP sockets, the address info is a pair (hostaddr, port). 
-        """ 
-        fd, addr = self._accept() 
-        sock = socket(self.family, self.type, self.proto, fileno=fd) 
-        # Issue #7995: if no default timeout is set and the listening 
-        # socket had a (non-zero) timeout, force the new socket in blocking 
-        # mode to override platform-specific socket flags inheritance. 
-        if getdefaulttimeout() is None and self.gettimeout(): 
-            sock.setblocking(True) 
-        return sock, addr 
- 
-    def makefile(self, mode="r", buffering=None, *, 
-                 encoding=None, errors=None, newline=None): 
-        """makefile(...) -> an I/O stream connected to the socket 
- 
-        The arguments are as for io.open() after the filename, except the only 
-        supported mode values are 'r' (default), 'w' and 'b'. 
-        """ 
-        # XXX refactor to share code? 
-        if not set(mode) <= {"r", "w", "b"}: 
-            raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,)) 
-        writing = "w" in mode 
-        reading = "r" in mode or not writing 
-        assert reading or writing 
-        binary = "b" in mode 
-        rawmode = "" 
-        if reading: 
-            rawmode += "r" 
-        if writing: 
-            rawmode += "w" 
-        raw = SocketIO(self, rawmode) 
-        self._io_refs += 1 
-        if buffering is None: 
-            buffering = -1 
-        if buffering < 0: 
-            buffering = io.DEFAULT_BUFFER_SIZE 
-        if buffering == 0: 
-            if not binary: 
-                raise ValueError("unbuffered streams must be binary") 
-            return raw 
-        if reading and writing: 
-            buffer = io.BufferedRWPair(raw, raw, buffering) 
-        elif reading: 
-            buffer = io.BufferedReader(raw, buffering) 
-        else: 
-            assert writing 
-            buffer = io.BufferedWriter(raw, buffering) 
-        if binary: 
-            return buffer 
-        text = io.TextIOWrapper(buffer, encoding, errors, newline) 
-        text.mode = mode 
-        return text 
- 
-    if hasattr(os, 'sendfile'): 
- 
-        def _sendfile_use_sendfile(self, file, offset=0, count=None): 
-            self._check_sendfile_params(file, offset, count) 
-            sockno = self.fileno() 
-            try: 
-                fileno = file.fileno() 
-            except (AttributeError, io.UnsupportedOperation) as err: 
-                raise _GiveupOnSendfile(err)  # not a regular file 
-            try: 
-                fsize = os.fstat(fileno).st_size 
-            except OSError as err: 
-                raise _GiveupOnSendfile(err)  # not a regular file 
-            if not fsize: 
-                return 0  # empty file 
+
+    def dup(self):
+        """dup() -> socket object
+
+        Duplicate the socket. Return a new socket object connected to the same
+        system resource. The new socket is non-inheritable.
+        """
+        fd = dup(self.fileno())
+        sock = self.__class__(self.family, self.type, self.proto, fileno=fd)
+        sock.settimeout(self.gettimeout())
+        return sock
+
+    def accept(self):
+        """accept() -> (socket object, address info)
+
+        Wait for an incoming connection.  Return a new socket
+        representing the connection, and the address of the client.
+        For IP sockets, the address info is a pair (hostaddr, port).
+        """
+        fd, addr = self._accept()
+        sock = socket(self.family, self.type, self.proto, fileno=fd)
+        # Issue #7995: if no default timeout is set and the listening
+        # socket had a (non-zero) timeout, force the new socket in blocking
+        # mode to override platform-specific socket flags inheritance.
+        if getdefaulttimeout() is None and self.gettimeout():
+            sock.setblocking(True)
+        return sock, addr
+
+    def makefile(self, mode="r", buffering=None, *,
+                 encoding=None, errors=None, newline=None):
+        """makefile(...) -> an I/O stream connected to the socket
+
+        The arguments are as for io.open() after the filename, except the only
+        supported mode values are 'r' (default), 'w' and 'b'.
+        """
+        # XXX refactor to share code?
+        if not set(mode) <= {"r", "w", "b"}:
+            raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,))
+        writing = "w" in mode
+        reading = "r" in mode or not writing
+        assert reading or writing
+        binary = "b" in mode
+        rawmode = ""
+        if reading:
+            rawmode += "r"
+        if writing:
+            rawmode += "w"
+        raw = SocketIO(self, rawmode)
+        self._io_refs += 1
+        if buffering is None:
+            buffering = -1
+        if buffering < 0:
+            buffering = io.DEFAULT_BUFFER_SIZE
+        if buffering == 0:
+            if not binary:
+                raise ValueError("unbuffered streams must be binary")
+            return raw
+        if reading and writing:
+            buffer = io.BufferedRWPair(raw, raw, buffering)
+        elif reading:
+            buffer = io.BufferedReader(raw, buffering)
+        else:
+            assert writing
+            buffer = io.BufferedWriter(raw, buffering)
+        if binary:
+            return buffer
+        text = io.TextIOWrapper(buffer, encoding, errors, newline)
+        text.mode = mode
+        return text
+
+    if hasattr(os, 'sendfile'):
+
+        def _sendfile_use_sendfile(self, file, offset=0, count=None):
+            self._check_sendfile_params(file, offset, count)
+            sockno = self.fileno()
+            try:
+                fileno = file.fileno()
+            except (AttributeError, io.UnsupportedOperation) as err:
+                raise _GiveupOnSendfile(err)  # not a regular file
+            try:
+                fsize = os.fstat(fileno).st_size
+            except OSError as err:
+                raise _GiveupOnSendfile(err)  # not a regular file
+            if not fsize:
+                return 0  # empty file
             # Truncate to 1GiB to avoid OverflowError, see bpo-38319.
             blocksize = min(count or fsize, 2 ** 30)
-            timeout = self.gettimeout() 
-            if timeout == 0: 
-                raise ValueError("non-blocking sockets are not supported") 
-            # poll/select have the advantage of not requiring any 
-            # extra file descriptor, contrarily to epoll/kqueue 
-            # (also, they require a single syscall). 
-            if hasattr(selectors, 'PollSelector'): 
-                selector = selectors.PollSelector() 
-            else: 
-                selector = selectors.SelectSelector() 
-            selector.register(sockno, selectors.EVENT_WRITE) 
- 
-            total_sent = 0 
-            # localize variable access to minimize overhead 
-            selector_select = selector.select 
-            os_sendfile = os.sendfile 
-            try: 
-                while True: 
-                    if timeout and not selector_select(timeout): 
-                        raise _socket.timeout('timed out') 
-                    if count: 
-                        blocksize = count - total_sent 
-                        if blocksize <= 0: 
-                            break 
-                    try: 
-                        sent = os_sendfile(sockno, fileno, offset, blocksize) 
-                    except BlockingIOError: 
-                        if not timeout: 
-                            # Block until the socket is ready to send some 
-                            # data; avoids hogging CPU resources. 
-                            selector_select() 
-                        continue 
-                    except OSError as err: 
-                        if total_sent == 0: 
-                            # We can get here for different reasons, the main 
-                            # one being 'file' is not a regular mmap(2)-like 
-                            # file, in which case we'll fall back on using 
-                            # plain send(). 
-                            raise _GiveupOnSendfile(err) 
-                        raise err from None 
-                    else: 
-                        if sent == 0: 
-                            break  # EOF 
-                        offset += sent 
-                        total_sent += sent 
-                return total_sent 
-            finally: 
-                if total_sent > 0 and hasattr(file, 'seek'): 
-                    file.seek(offset) 
-    else: 
-        def _sendfile_use_sendfile(self, file, offset=0, count=None): 
-            raise _GiveupOnSendfile( 
-                "os.sendfile() not available on this platform") 
- 
-    def _sendfile_use_send(self, file, offset=0, count=None): 
-        self._check_sendfile_params(file, offset, count) 
-        if self.gettimeout() == 0: 
-            raise ValueError("non-blocking sockets are not supported") 
-        if offset: 
-            file.seek(offset) 
-        blocksize = min(count, 8192) if count else 8192 
-        total_sent = 0 
-        # localize variable access to minimize overhead 
-        file_read = file.read 
-        sock_send = self.send 
-        try: 
-            while True: 
-                if count: 
-                    blocksize = min(count - total_sent, blocksize) 
-                    if blocksize <= 0: 
-                        break 
-                data = memoryview(file_read(blocksize)) 
-                if not data: 
-                    break  # EOF 
-                while True: 
-                    try: 
-                        sent = sock_send(data) 
-                    except BlockingIOError: 
-                        continue 
-                    else: 
-                        total_sent += sent 
-                        if sent < len(data): 
-                            data = data[sent:] 
-                        else: 
-                            break 
-            return total_sent 
-        finally: 
-            if total_sent > 0 and hasattr(file, 'seek'): 
-                file.seek(offset + total_sent) 
- 
-    def _check_sendfile_params(self, file, offset, count): 
-        if 'b' not in getattr(file, 'mode', 'b'): 
-            raise ValueError("file should be opened in binary mode") 
-        if not self.type & SOCK_STREAM: 
-            raise ValueError("only SOCK_STREAM type sockets are supported") 
-        if count is not None: 
-            if not isinstance(count, int): 
-                raise TypeError( 
-                    "count must be a positive integer (got {!r})".format(count)) 
-            if count <= 0: 
-                raise ValueError( 
-                    "count must be a positive integer (got {!r})".format(count)) 
- 
-    def sendfile(self, file, offset=0, count=None): 
-        """sendfile(file[, offset[, count]]) -> sent 
- 
-        Send a file until EOF is reached by using high-performance 
-        os.sendfile() and return the total number of bytes which 
-        were sent. 
-        *file* must be a regular file object opened in binary mode. 
-        If os.sendfile() is not available (e.g. Windows) or file is 
-        not a regular file socket.send() will be used instead. 
-        *offset* tells from where to start reading the file. 
-        If specified, *count* is the total number of bytes to transmit 
-        as opposed to sending the file until EOF is reached. 
-        File position is updated on return or also in case of error in 
-        which case file.tell() can be used to figure out the number of 
-        bytes which were sent. 
-        The socket must be of SOCK_STREAM type. 
-        Non-blocking sockets are not supported. 
-        """ 
-        try: 
-            return self._sendfile_use_sendfile(file, offset, count) 
-        except _GiveupOnSendfile: 
-            return self._sendfile_use_send(file, offset, count) 
- 
-    def _decref_socketios(self): 
-        if self._io_refs > 0: 
-            self._io_refs -= 1 
-        if self._closed: 
-            self.close() 
- 
-    def _real_close(self, _ss=_socket.socket): 
-        # This function should not reference any globals. See issue #808164. 
-        _ss.close(self) 
- 
-    def close(self): 
-        # This function should not reference any globals. See issue #808164. 
-        self._closed = True 
-        if self._io_refs <= 0: 
-            self._real_close() 
- 
-    def detach(self): 
-        """detach() -> file descriptor 
- 
-        Close the socket object without closing the underlying file descriptor. 
-        The object cannot be used after this call, but the file descriptor 
-        can be reused for other purposes.  The file descriptor is returned. 
-        """ 
-        self._closed = True 
-        return super().detach() 
- 
-    @property 
-    def family(self): 
-        """Read-only access to the address family for this socket. 
-        """ 
-        return _intenum_converter(super().family, AddressFamily) 
- 
-    @property 
-    def type(self): 
-        """Read-only access to the socket type. 
-        """ 
-        return _intenum_converter(super().type, SocketKind) 
- 
-    if os.name == 'nt': 
-        def get_inheritable(self): 
-            return os.get_handle_inheritable(self.fileno()) 
-        def set_inheritable(self, inheritable): 
-            os.set_handle_inheritable(self.fileno(), inheritable) 
-    else: 
-        def get_inheritable(self): 
-            return os.get_inheritable(self.fileno()) 
-        def set_inheritable(self, inheritable): 
-            os.set_inheritable(self.fileno(), inheritable) 
-    get_inheritable.__doc__ = "Get the inheritable flag of the socket" 
-    set_inheritable.__doc__ = "Set the inheritable flag of the socket" 
- 
-def fromfd(fd, family, type, proto=0): 
-    """ fromfd(fd, family, type[, proto]) -> socket object 
- 
-    Create a socket object from a duplicate of the given file 
-    descriptor.  The remaining arguments are the same as for socket(). 
-    """ 
-    nfd = dup(fd) 
-    return socket(family, type, proto, nfd) 
- 
+            timeout = self.gettimeout()
+            if timeout == 0:
+                raise ValueError("non-blocking sockets are not supported")
+            # poll/select have the advantage of not requiring any
+            # extra file descriptor, contrarily to epoll/kqueue
+            # (also, they require a single syscall).
+            if hasattr(selectors, 'PollSelector'):
+                selector = selectors.PollSelector()
+            else:
+                selector = selectors.SelectSelector()
+            selector.register(sockno, selectors.EVENT_WRITE)
+
+            total_sent = 0
+            # localize variable access to minimize overhead
+            selector_select = selector.select
+            os_sendfile = os.sendfile
+            try:
+                while True:
+                    if timeout and not selector_select(timeout):
+                        raise _socket.timeout('timed out')
+                    if count:
+                        blocksize = count - total_sent
+                        if blocksize <= 0:
+                            break
+                    try:
+                        sent = os_sendfile(sockno, fileno, offset, blocksize)
+                    except BlockingIOError:
+                        if not timeout:
+                            # Block until the socket is ready to send some
+                            # data; avoids hogging CPU resources.
+                            selector_select()
+                        continue
+                    except OSError as err:
+                        if total_sent == 0:
+                            # We can get here for different reasons, the main
+                            # one being 'file' is not a regular mmap(2)-like
+                            # file, in which case we'll fall back on using
+                            # plain send().
+                            raise _GiveupOnSendfile(err)
+                        raise err from None
+                    else:
+                        if sent == 0:
+                            break  # EOF
+                        offset += sent
+                        total_sent += sent
+                return total_sent
+            finally:
+                if total_sent > 0 and hasattr(file, 'seek'):
+                    file.seek(offset)
+    else:
+        def _sendfile_use_sendfile(self, file, offset=0, count=None):
+            raise _GiveupOnSendfile(
+                "os.sendfile() not available on this platform")
+
+    def _sendfile_use_send(self, file, offset=0, count=None):
+        self._check_sendfile_params(file, offset, count)
+        if self.gettimeout() == 0:
+            raise ValueError("non-blocking sockets are not supported")
+        if offset:
+            file.seek(offset)
+        blocksize = min(count, 8192) if count else 8192
+        total_sent = 0
+        # localize variable access to minimize overhead
+        file_read = file.read
+        sock_send = self.send
+        try:
+            while True:
+                if count:
+                    blocksize = min(count - total_sent, blocksize)
+                    if blocksize <= 0:
+                        break
+                data = memoryview(file_read(blocksize))
+                if not data:
+                    break  # EOF
+                while True:
+                    try:
+                        sent = sock_send(data)
+                    except BlockingIOError:
+                        continue
+                    else:
+                        total_sent += sent
+                        if sent < len(data):
+                            data = data[sent:]
+                        else:
+                            break
+            return total_sent
+        finally:
+            if total_sent > 0 and hasattr(file, 'seek'):
+                file.seek(offset + total_sent)
+
+    def _check_sendfile_params(self, file, offset, count):
+        if 'b' not in getattr(file, 'mode', 'b'):
+            raise ValueError("file should be opened in binary mode")
+        if not self.type & SOCK_STREAM:
+            raise ValueError("only SOCK_STREAM type sockets are supported")
+        if count is not None:
+            if not isinstance(count, int):
+                raise TypeError(
+                    "count must be a positive integer (got {!r})".format(count))
+            if count <= 0:
+                raise ValueError(
+                    "count must be a positive integer (got {!r})".format(count))
+
+    def sendfile(self, file, offset=0, count=None):
+        """sendfile(file[, offset[, count]]) -> sent
+
+        Send a file until EOF is reached by using high-performance
+        os.sendfile() and return the total number of bytes which
+        were sent.
+        *file* must be a regular file object opened in binary mode.
+        If os.sendfile() is not available (e.g. Windows) or file is
+        not a regular file socket.send() will be used instead.
+        *offset* tells from where to start reading the file.
+        If specified, *count* is the total number of bytes to transmit
+        as opposed to sending the file until EOF is reached.
+        File position is updated on return or also in case of error in
+        which case file.tell() can be used to figure out the number of
+        bytes which were sent.
+        The socket must be of SOCK_STREAM type.
+        Non-blocking sockets are not supported.
+        """
+        try:
+            return self._sendfile_use_sendfile(file, offset, count)
+        except _GiveupOnSendfile:
+            return self._sendfile_use_send(file, offset, count)
+
+    def _decref_socketios(self):
+        if self._io_refs > 0:
+            self._io_refs -= 1
+        if self._closed:
+            self.close()
+
+    def _real_close(self, _ss=_socket.socket):
+        # This function should not reference any globals. See issue #808164.
+        _ss.close(self)
+
+    def close(self):
+        # This function should not reference any globals. See issue #808164.
+        self._closed = True
+        if self._io_refs <= 0:
+            self._real_close()
+
+    def detach(self):
+        """detach() -> file descriptor
+
+        Close the socket object without closing the underlying file descriptor.
+        The object cannot be used after this call, but the file descriptor
+        can be reused for other purposes.  The file descriptor is returned.
+        """
+        self._closed = True
+        return super().detach()
+
+    @property
+    def family(self):
+        """Read-only access to the address family for this socket.
+        """
+        return _intenum_converter(super().family, AddressFamily)
+
+    @property
+    def type(self):
+        """Read-only access to the socket type.
+        """
+        return _intenum_converter(super().type, SocketKind)
+
+    if os.name == 'nt':
+        def get_inheritable(self):
+            return os.get_handle_inheritable(self.fileno())
+        def set_inheritable(self, inheritable):
+            os.set_handle_inheritable(self.fileno(), inheritable)
+    else:
+        def get_inheritable(self):
+            return os.get_inheritable(self.fileno())
+        def set_inheritable(self, inheritable):
+            os.set_inheritable(self.fileno(), inheritable)
+    get_inheritable.__doc__ = "Get the inheritable flag of the socket"
+    set_inheritable.__doc__ = "Set the inheritable flag of the socket"
+
+def fromfd(fd, family, type, proto=0):
+    """ fromfd(fd, family, type[, proto]) -> socket object
+
+    Create a socket object from a duplicate of the given file
+    descriptor.  The remaining arguments are the same as for socket().
+    """
+    nfd = dup(fd)
+    return socket(family, type, proto, nfd)
+
 if hasattr(_socket.socket, "sendmsg"):
     import array
 
@@ -578,276 +578,276 @@ if hasattr(_socket.socket, "recvmsg"):
         return msg, list(fds), flags, addr
     __all__.append("recv_fds")
 
-if hasattr(_socket.socket, "share"): 
-    def fromshare(info): 
-        """ fromshare(info) -> socket object 
- 
-        Create a socket object from the bytes object returned by 
-        socket.share(pid). 
-        """ 
-        return socket(0, 0, 0, info) 
-    __all__.append("fromshare") 
- 
-if hasattr(_socket, "socketpair"): 
- 
-    def socketpair(family=None, type=SOCK_STREAM, proto=0): 
-        """socketpair([family[, type[, proto]]]) -> (socket object, socket object) 
- 
-        Create a pair of socket objects from the sockets returned by the platform 
-        socketpair() function. 
-        The arguments are the same as for socket() except the default family is 
-        AF_UNIX if defined on the platform; otherwise, the default is AF_INET. 
-        """ 
-        if family is None: 
-            try: 
-                family = AF_UNIX 
-            except NameError: 
-                family = AF_INET 
-        a, b = _socket.socketpair(family, type, proto) 
-        a = socket(family, type, proto, a.detach()) 
-        b = socket(family, type, proto, b.detach()) 
-        return a, b 
- 
-else: 
- 
-    # Origin: https://gist.github.com/4325783, by Geert Jansen.  Public domain. 
-    def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0): 
-        if family == AF_INET: 
-            host = _LOCALHOST 
-        elif family == AF_INET6: 
-            host = _LOCALHOST_V6 
-        else: 
-            raise ValueError("Only AF_INET and AF_INET6 socket address families " 
-                             "are supported") 
-        if type != SOCK_STREAM: 
-            raise ValueError("Only SOCK_STREAM socket type is supported") 
-        if proto != 0: 
-            raise ValueError("Only protocol zero is supported") 
- 
-        # We create a connected TCP socket. Note the trick with 
-        # setblocking(False) that prevents us from having to create a thread. 
-        lsock = socket(family, type, proto) 
-        try: 
-            lsock.bind((host, 0)) 
-            lsock.listen() 
-            # On IPv6, ignore flow_info and scope_id 
-            addr, port = lsock.getsockname()[:2] 
-            csock = socket(family, type, proto) 
-            try: 
-                csock.setblocking(False) 
-                try: 
-                    csock.connect((addr, port)) 
-                except (BlockingIOError, InterruptedError): 
-                    pass 
-                csock.setblocking(True) 
-                ssock, _ = lsock.accept() 
-            except: 
-                csock.close() 
-                raise 
-        finally: 
-            lsock.close() 
-        return (ssock, csock) 
-    __all__.append("socketpair") 
- 
-socketpair.__doc__ = """socketpair([family[, type[, proto]]]) -> (socket object, socket object) 
-Create a pair of socket objects from the sockets returned by the platform 
-socketpair() function. 
-The arguments are the same as for socket() except the default family is AF_UNIX 
-if defined on the platform; otherwise, the default is AF_INET. 
-""" 
- 
-_blocking_errnos = { EAGAIN, EWOULDBLOCK } 
- 
-class SocketIO(io.RawIOBase): 
- 
-    """Raw I/O implementation for stream sockets. 
- 
-    This class supports the makefile() method on sockets.  It provides 
-    the raw I/O interface on top of a socket object. 
-    """ 
- 
-    # One might wonder why not let FileIO do the job instead.  There are two 
-    # main reasons why FileIO is not adapted: 
-    # - it wouldn't work under Windows (where you can't used read() and 
-    #   write() on a socket handle) 
-    # - it wouldn't work with socket timeouts (FileIO would ignore the 
-    #   timeout and consider the socket non-blocking) 
- 
-    # XXX More docs 
- 
-    def __init__(self, sock, mode): 
-        if mode not in ("r", "w", "rw", "rb", "wb", "rwb"): 
-            raise ValueError("invalid mode: %r" % mode) 
-        io.RawIOBase.__init__(self) 
-        self._sock = sock 
-        if "b" not in mode: 
-            mode += "b" 
-        self._mode = mode 
-        self._reading = "r" in mode 
-        self._writing = "w" in mode 
-        self._timeout_occurred = False 
- 
-    def readinto(self, b): 
-        """Read up to len(b) bytes into the writable buffer *b* and return 
-        the number of bytes read.  If the socket is non-blocking and no bytes 
-        are available, None is returned. 
- 
-        If *b* is non-empty, a 0 return value indicates that the connection 
-        was shutdown at the other end. 
-        """ 
-        self._checkClosed() 
-        self._checkReadable() 
-        if self._timeout_occurred: 
-            raise OSError("cannot read from timed out object") 
-        while True: 
-            try: 
-                return self._sock.recv_into(b) 
-            except timeout: 
-                self._timeout_occurred = True 
-                raise 
-            except error as e: 
-                if e.args[0] in _blocking_errnos: 
-                    return None 
-                raise 
- 
-    def write(self, b): 
-        """Write the given bytes or bytearray object *b* to the socket 
-        and return the number of bytes written.  This can be less than 
-        len(b) if not all data could be written.  If the socket is 
-        non-blocking and no bytes could be written None is returned. 
-        """ 
-        self._checkClosed() 
-        self._checkWritable() 
-        try: 
-            return self._sock.send(b) 
-        except error as e: 
-            # XXX what about EINTR? 
-            if e.args[0] in _blocking_errnos: 
-                return None 
-            raise 
- 
-    def readable(self): 
-        """True if the SocketIO is open for reading. 
-        """ 
-        if self.closed: 
-            raise ValueError("I/O operation on closed socket.") 
-        return self._reading 
- 
-    def writable(self): 
-        """True if the SocketIO is open for writing. 
-        """ 
-        if self.closed: 
-            raise ValueError("I/O operation on closed socket.") 
-        return self._writing 
- 
-    def seekable(self): 
-        """True if the SocketIO is open for seeking. 
-        """ 
-        if self.closed: 
-            raise ValueError("I/O operation on closed socket.") 
-        return super().seekable() 
- 
-    def fileno(self): 
-        """Return the file descriptor of the underlying socket. 
-        """ 
-        self._checkClosed() 
-        return self._sock.fileno() 
- 
-    @property 
-    def name(self): 
-        if not self.closed: 
-            return self.fileno() 
-        else: 
-            return -1 
- 
-    @property 
-    def mode(self): 
-        return self._mode 
- 
-    def close(self): 
-        """Close the SocketIO object.  This doesn't close the underlying 
-        socket, except if all references to it have disappeared. 
-        """ 
-        if self.closed: 
-            return 
-        io.RawIOBase.close(self) 
-        self._sock._decref_socketios() 
-        self._sock = None 
- 
- 
-def getfqdn(name=''): 
-    """Get fully qualified domain name from name. 
- 
-    An empty argument is interpreted as meaning the local host. 
- 
-    First the hostname returned by gethostbyaddr() is checked, then 
+if hasattr(_socket.socket, "share"):
+    def fromshare(info):
+        """ fromshare(info) -> socket object
+
+        Create a socket object from the bytes object returned by
+        socket.share(pid).
+        """
+        return socket(0, 0, 0, info)
+    __all__.append("fromshare")
+
+if hasattr(_socket, "socketpair"):
+
+    def socketpair(family=None, type=SOCK_STREAM, proto=0):
+        """socketpair([family[, type[, proto]]]) -> (socket object, socket object)
+
+        Create a pair of socket objects from the sockets returned by the platform
+        socketpair() function.
+        The arguments are the same as for socket() except the default family is
+        AF_UNIX if defined on the platform; otherwise, the default is AF_INET.
+        """
+        if family is None:
+            try:
+                family = AF_UNIX
+            except NameError:
+                family = AF_INET
+        a, b = _socket.socketpair(family, type, proto)
+        a = socket(family, type, proto, a.detach())
+        b = socket(family, type, proto, b.detach())
+        return a, b
+
+else:
+
+    # Origin: https://gist.github.com/4325783, by Geert Jansen.  Public domain.
+    def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0):
+        if family == AF_INET:
+            host = _LOCALHOST
+        elif family == AF_INET6:
+            host = _LOCALHOST_V6
+        else:
+            raise ValueError("Only AF_INET and AF_INET6 socket address families "
+                             "are supported")
+        if type != SOCK_STREAM:
+            raise ValueError("Only SOCK_STREAM socket type is supported")
+        if proto != 0:
+            raise ValueError("Only protocol zero is supported")
+
+        # We create a connected TCP socket. Note the trick with
+        # setblocking(False) that prevents us from having to create a thread.
+        lsock = socket(family, type, proto)
+        try:
+            lsock.bind((host, 0))
+            lsock.listen()
+            # On IPv6, ignore flow_info and scope_id
+            addr, port = lsock.getsockname()[:2]
+            csock = socket(family, type, proto)
+            try:
+                csock.setblocking(False)
+                try:
+                    csock.connect((addr, port))
+                except (BlockingIOError, InterruptedError):
+                    pass
+                csock.setblocking(True)
+                ssock, _ = lsock.accept()
+            except:
+                csock.close()
+                raise
+        finally:
+            lsock.close()
+        return (ssock, csock)
+    __all__.append("socketpair")
+
+socketpair.__doc__ = """socketpair([family[, type[, proto]]]) -> (socket object, socket object)
+Create a pair of socket objects from the sockets returned by the platform
+socketpair() function.
+The arguments are the same as for socket() except the default family is AF_UNIX
+if defined on the platform; otherwise, the default is AF_INET.
+"""
+
+_blocking_errnos = { EAGAIN, EWOULDBLOCK }
+
+class SocketIO(io.RawIOBase):
+
+    """Raw I/O implementation for stream sockets.
+
+    This class supports the makefile() method on sockets.  It provides
+    the raw I/O interface on top of a socket object.
+    """
+
+    # One might wonder why not let FileIO do the job instead.  There are two
+    # main reasons why FileIO is not adapted:
+    # - it wouldn't work under Windows (where you can't used read() and
+    #   write() on a socket handle)
+    # - it wouldn't work with socket timeouts (FileIO would ignore the
+    #   timeout and consider the socket non-blocking)
+
+    # XXX More docs
+
+    def __init__(self, sock, mode):
+        if mode not in ("r", "w", "rw", "rb", "wb", "rwb"):
+            raise ValueError("invalid mode: %r" % mode)
+        io.RawIOBase.__init__(self)
+        self._sock = sock
+        if "b" not in mode:
+            mode += "b"
+        self._mode = mode
+        self._reading = "r" in mode
+        self._writing = "w" in mode
+        self._timeout_occurred = False
+
+    def readinto(self, b):
+        """Read up to len(b) bytes into the writable buffer *b* and return
+        the number of bytes read.  If the socket is non-blocking and no bytes
+        are available, None is returned.
+
+        If *b* is non-empty, a 0 return value indicates that the connection
+        was shutdown at the other end.
+        """
+        self._checkClosed()
+        self._checkReadable()
+        if self._timeout_occurred:
+            raise OSError("cannot read from timed out object")
+        while True:
+            try:
+                return self._sock.recv_into(b)
+            except timeout:
+                self._timeout_occurred = True
+                raise
+            except error as e:
+                if e.args[0] in _blocking_errnos:
+                    return None
+                raise
+
+    def write(self, b):
+        """Write the given bytes or bytearray object *b* to the socket
+        and return the number of bytes written.  This can be less than
+        len(b) if not all data could be written.  If the socket is
+        non-blocking and no bytes could be written None is returned.
+        """
+        self._checkClosed()
+        self._checkWritable()
+        try:
+            return self._sock.send(b)
+        except error as e:
+            # XXX what about EINTR?
+            if e.args[0] in _blocking_errnos:
+                return None
+            raise
+
+    def readable(self):
+        """True if the SocketIO is open for reading.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed socket.")
+        return self._reading
+
+    def writable(self):
+        """True if the SocketIO is open for writing.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed socket.")
+        return self._writing
+
+    def seekable(self):
+        """True if the SocketIO is open for seeking.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed socket.")
+        return super().seekable()
+
+    def fileno(self):
+        """Return the file descriptor of the underlying socket.
+        """
+        self._checkClosed()
+        return self._sock.fileno()
+
+    @property
+    def name(self):
+        if not self.closed:
+            return self.fileno()
+        else:
+            return -1
+
+    @property
+    def mode(self):
+        return self._mode
+
+    def close(self):
+        """Close the SocketIO object.  This doesn't close the underlying
+        socket, except if all references to it have disappeared.
+        """
+        if self.closed:
+            return
+        io.RawIOBase.close(self)
+        self._sock._decref_socketios()
+        self._sock = None
+
+
+def getfqdn(name=''):
+    """Get fully qualified domain name from name.
+
+    An empty argument is interpreted as meaning the local host.
+
+    First the hostname returned by gethostbyaddr() is checked, then
     possibly existing aliases. In case no FQDN is available and `name`
     was given, it is returned unchanged. If `name` was empty or '0.0.0.0',
     hostname from gethostname() is returned.
-    """ 
-    name = name.strip() 
-    if not name or name == '0.0.0.0': 
-        name = gethostname() 
-    try: 
-        hostname, aliases, ipaddrs = gethostbyaddr(name) 
-    except error: 
-        pass 
-    else: 
-        aliases.insert(0, hostname) 
-        for name in aliases: 
-            if '.' in name: 
-                break 
-        else: 
-            name = hostname 
-    return name 
- 
- 
-_GLOBAL_DEFAULT_TIMEOUT = object() 
- 
-def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT, 
-                      source_address=None): 
-    """Connect to *address* and return the socket object. 
- 
-    Convenience function.  Connect to *address* (a 2-tuple ``(host, 
-    port)``) and return the socket object.  Passing the optional 
-    *timeout* parameter will set the timeout on the socket instance 
-    before attempting to connect.  If no *timeout* is supplied, the 
-    global default timeout setting returned by :func:`getdefaulttimeout` 
-    is used.  If *source_address* is set it must be a tuple of (host, port) 
-    for the socket to bind as a source address before making the connection. 
-    A host of '' or port 0 tells the OS to use the default. 
-    """ 
- 
-    host, port = address 
-    err = None 
-    for res in getaddrinfo(host, port, 0, SOCK_STREAM): 
-        af, socktype, proto, canonname, sa = res 
-        sock = None 
-        try: 
-            sock = socket(af, socktype, proto) 
-            if timeout is not _GLOBAL_DEFAULT_TIMEOUT: 
-                sock.settimeout(timeout) 
-            if source_address: 
-                sock.bind(source_address) 
-            sock.connect(sa) 
-            # Break explicitly a reference cycle 
-            err = None 
-            return sock 
- 
-        except error as _: 
-            err = _ 
-            if sock is not None: 
-                sock.close() 
- 
-    if err is not None: 
+    """
+    name = name.strip()
+    if not name or name == '0.0.0.0':
+        name = gethostname()
+    try:
+        hostname, aliases, ipaddrs = gethostbyaddr(name)
+    except error:
+        pass
+    else:
+        aliases.insert(0, hostname)
+        for name in aliases:
+            if '.' in name:
+                break
+        else:
+            name = hostname
+    return name
+
+
+_GLOBAL_DEFAULT_TIMEOUT = object()
+
+def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,
+                      source_address=None):
+    """Connect to *address* and return the socket object.
+
+    Convenience function.  Connect to *address* (a 2-tuple ``(host,
+    port)``) and return the socket object.  Passing the optional
+    *timeout* parameter will set the timeout on the socket instance
+    before attempting to connect.  If no *timeout* is supplied, the
+    global default timeout setting returned by :func:`getdefaulttimeout`
+    is used.  If *source_address* is set it must be a tuple of (host, port)
+    for the socket to bind as a source address before making the connection.
+    A host of '' or port 0 tells the OS to use the default.
+    """
+
+    host, port = address
+    err = None
+    for res in getaddrinfo(host, port, 0, SOCK_STREAM):
+        af, socktype, proto, canonname, sa = res
+        sock = None
+        try:
+            sock = socket(af, socktype, proto)
+            if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
+                sock.settimeout(timeout)
+            if source_address:
+                sock.bind(source_address)
+            sock.connect(sa)
+            # Break explicitly a reference cycle
+            err = None
+            return sock
+
+        except error as _:
+            err = _
+            if sock is not None:
+                sock.close()
+
+    if err is not None:
         try:
             raise err
         finally:
             # Break explicitly a reference cycle
             err = None
-    else: 
-        raise error("getaddrinfo returns an empty list") 
- 
+    else:
+        raise error("getaddrinfo returns an empty list")
+
 
 def has_dualstack_ipv6():
     """Return True if the platform supports creating a SOCK_STREAM socket
@@ -934,26 +934,26 @@ def create_server(address, *, family=AF_INET, backlog=None, reuse_port=False,
         raise
 
 
-def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0): 
-    """Resolve host and port into list of address info entries. 
- 
-    Translate the host/port argument into a sequence of 5-tuples that contain 
-    all the necessary arguments for creating a socket connected to that service. 
-    host is a domain name, a string representation of an IPv4/v6 address or 
-    None. port is a string service name such as 'http', a numeric port number or 
-    None. By passing None as the value of host and port, you can pass NULL to 
-    the underlying C API. 
- 
-    The family, type and proto arguments can be optionally specified in order to 
-    narrow the list of addresses returned. Passing zero as a value for each of 
-    these arguments selects the full range of results. 
-    """ 
-    # We override this function since we want to translate the numeric family 
-    # and socket type values to enum constants. 
-    addrlist = [] 
-    for res in _socket.getaddrinfo(host, port, family, type, proto, flags): 
-        af, socktype, proto, canonname, sa = res 
-        addrlist.append((_intenum_converter(af, AddressFamily), 
-                         _intenum_converter(socktype, SocketKind), 
-                         proto, canonname, sa)) 
-    return addrlist 
+def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
+    """Resolve host and port into list of address info entries.
+
+    Translate the host/port argument into a sequence of 5-tuples that contain
+    all the necessary arguments for creating a socket connected to that service.
+    host is a domain name, a string representation of an IPv4/v6 address or
+    None. port is a string service name such as 'http', a numeric port number or
+    None. By passing None as the value of host and port, you can pass NULL to
+    the underlying C API.
+
+    The family, type and proto arguments can be optionally specified in order to
+    narrow the list of addresses returned. Passing zero as a value for each of
+    these arguments selects the full range of results.
+    """
+    # We override this function since we want to translate the numeric family
+    # and socket type values to enum constants.
+    addrlist = []
+    for res in _socket.getaddrinfo(host, port, family, type, proto, flags):
+        af, socktype, proto, canonname, sa = res
+        addrlist.append((_intenum_converter(af, AddressFamily),
+                         _intenum_converter(socktype, SocketKind),
+                         proto, canonname, sa))
+    return addrlist