More flake8 fixes.

1 files changed, 47 insertions, 21 deletions

diff --git a/paramiko/sftp_file.py b/paramiko/sftp_file.py
index 391d7b0c..9ebaaf66 100644
--- a/paramiko/sftp_file.py
+++ b/paramiko/sftp_file.py
@@ -31,8 +31,8 @@ from paramiko.common import DEBUG
 
 from paramiko.file import BufferedFile
 from paramiko.py3compat import long
-from paramiko.sftp import CMD_CLOSE, CMD_READ, CMD_DATA, SFTPError, CMD_WRITE, \
-    CMD_STATUS, CMD_FSTAT, CMD_ATTRS, CMD_FSETSTAT, CMD_EXTENDED
+from paramiko.sftp import CMD_CLOSE, CMD_READ, CMD_DATA, SFTPError,\
+    CMD_WRITE, CMD_STATUS, CMD_FSTAT, CMD_ATTRS, CMD_FSETSTAT, CMD_EXTENDED
 from paramiko.sftp_attr import SFTPAttributes
 
 
@@ -87,7 +87,8 @@ class SFTPFile (BufferedFile):
         BufferedFile.close(self)
         try:
             if async:
-                # GC'd file handle could be called from an arbitrary thread -- don't wait for a response
+                # GC'd file handle could be called from an arbitrary thread
+                # -- don't wait for a response
                 self.sftp._async_request(type(None), CMD_CLOSE, self.handle)
             else:
                 self.sftp._request(CMD_CLOSE, self.handle)
@@ -99,7 +100,8 @@ class SFTPFile (BufferedFile):
             pass
 
     def _data_in_prefetch_requests(self, offset, size):
-        k = [x for x in list(self._prefetch_extents.values()) if x[0] <= offset]
+        k = [x for x in list(self._prefetch_extents.values())
+             if x[0] <= offset]
         if len(k) == 0:
             return False
         k.sort(key=lambda x: x[0])
@@ -110,8 +112,11 @@ class SFTPFile (BufferedFile):
         if buf_offset + buf_size >= offset + size:
             # inclusive
             return True
-        # well, we have part of the request.  see if another chunk has the rest.
-        return self._data_in_prefetch_requests(buf_offset + buf_size, offset + size - buf_offset - buf_size)
+        # well, we have part of the request.  see if another chunk has
+        # the rest.
+        return self._data_in_prefetch_requests(
+            buf_offset + buf_size,
+            offset + size - buf_offset - buf_size)
 
     def _data_in_prefetch_buffers(self, offset):
         """
@@ -135,7 +140,8 @@ class SFTPFile (BufferedFile):
         read data out of the prefetch buffer, if possible.  if the data isn't
         in the buffer, return None.  otherwise, behaves like a normal read.
         """
-        # while not closed, and haven't fetched past the current position, and haven't reached EOF...
+        # while not closed, and haven't fetched past the current position,
+        # and haven't reached EOF...
         while True:
             offset = self._data_in_prefetch_buffers(self._realpos)
             if offset is not None:
@@ -165,7 +171,12 @@ class SFTPFile (BufferedFile):
             data = self._read_prefetch(size)
             if data is not None:
                 return data
-        t, msg = self.sftp._request(CMD_READ, self.handle, long(self._realpos), int(size))
+        t, msg = self.sftp._request(
+            CMD_READ,
+            self.handle,
+            long(self._realpos),
+            int(size)
+        )
         if t != CMD_DATA:
             raise SFTPError('Expected data')
         return msg.get_string()
@@ -173,8 +184,16 @@ class SFTPFile (BufferedFile):
     def _write(self, data):
         # may write less than requested if it would exceed max packet size
         chunk = min(len(data), self.MAX_REQUEST_SIZE)
-        self._reqs.append(self.sftp._async_request(type(None), CMD_WRITE, self.handle, long(self._realpos), data[:chunk]))
-        if not self.pipelined or (len(self._reqs) > 100 and self.sftp.sock.recv_ready()):
+        sftp_async_request = self.sftp._async_request(
+            type(None),
+            CMD_WRITE,
+            self.handle,
+            long(self._realpos),
+            data[:chunk]
+        )
+        self._reqs.append(sftp_async_request)
+        if not self.pipelined or \
+                (len(self._reqs) > 100 and self.sftp.sock.recv_ready()):
             while len(self._reqs):
                 req = self._reqs.popleft()
                 t, msg = self.sftp._read_response(req)
@@ -244,7 +263,8 @@ class SFTPFile (BufferedFile):
         exactly like `.SFTPClient.stat`, except that it operates on an
         already-open file.
 
-        :return: an `.SFTPAttributes` object containing attributes about this file.
+        :return: an `.SFTPAttributes` object containing attributes about this
+            file.
         """
         t, msg = self.sftp._request(CMD_FSTAT, self.handle)
         if t != CMD_ATTRS:
@@ -284,11 +304,11 @@ class SFTPFile (BufferedFile):
     def utime(self, times):
         """
         Set the access and modified times of this file.  If
-        ``times`` is ``None``, then the file's access and modified times are set
-        to the current time.  Otherwise, ``times`` must be a 2-tuple of numbers,
-        of the form ``(atime, mtime)``, which is used to set the access and
-        modified times, respectively.  This bizarre API is mimicked from Python
-        for the sake of consistency -- I apologize.
+        ``times`` is ``None``, then the file's access and modified times are
+        set to the current time.  Otherwise, ``times`` must be a 2-tuple of
+        numbers, of the form ``(atime, mtime)``, which is used to set the
+        access and modified times, respectively.  This bizarre API is mimicked
+        from Python for the sake of consistency -- I apologize.
 
         :param tuple times:
             ``None`` or a tuple of (access time, modified time) in standard
@@ -323,9 +343,9 @@ class SFTPFile (BufferedFile):
         to verify a successful upload or download, or for various rsync-like
         operations.
 
-        The file is hashed from ``offset``, for ``length`` bytes.  If ``length``
-        is 0, the remainder of the file is hashed.  Thus, if both ``offset``
-        and ``length`` are zero, the entire file is hashed.
+        The file is hashed from ``offset``, for ``length`` bytes.
+        If ``length`` is 0, the remainder of the file is hashed.  Thus, if both
+        ``offset`` and ``length`` are zero, the entire file is hashed.
 
         Normally, ``block_size`` will be 0 (the default), and this method will
         return a byte string representing the requested hash (for example, a
@@ -454,7 +474,8 @@ class SFTPFile (BufferedFile):
         read_chunks = []
         for offset, size in chunks:
             # don't fetch data that's already in the prefetch buffer
-            if self._data_in_prefetch_buffers(offset) or self._data_in_prefetch_requests(offset, size):
+            if self._data_in_prefetch_buffers(offset) or \
+                    self._data_in_prefetch_requests(offset, size):
                 continue
 
             # break up anything larger than the max read size
@@ -490,7 +511,12 @@ class SFTPFile (BufferedFile):
         # do these read requests in a temporary thread because there may be
         # a lot of them, so it may block.
         for offset, length in chunks:
-            num = self.sftp._async_request(self, CMD_READ, self.handle, long(offset), int(length))
+            num = self.sftp._async_request(
+                self,
+                CMD_READ,
+                self.handle,
+                long(offset),
+                int(length))
             with self._prefetch_lock:
                 self._prefetch_extents[num] = (offset, length)