More flake8 fixes.

3 files changed, 53 insertions, 30 deletions

diff --git a/paramiko/kex_gss.py b/paramiko/kex_gss.py
index e21d55b9..483c2dec 100644
--- a/paramiko/kex_gss.py
+++ b/paramiko/kex_gss.py
@@ -584,7 +584,7 @@ class KexGSSGex(object):
         maj_status = m.get_int()
         min_status = m.get_int()
         err_msg = m.get_string()
-        lang_tag = m.get_string()   # we don't care about the language!
+        m.get_string()   # we don't care about the language (lang_tag)!
         raise SSHException("GSS-API Error:\nMajor Status: %s\nMinor Status: %s\
                             \nError Message: %s\n") % (str(maj_status),
                                                        str(min_status),
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)
 
diff --git a/paramiko/ssh_gss.py b/paramiko/ssh_gss.py
index 6cde0da5..8bb0c2e0 100644
--- a/paramiko/ssh_gss.py
+++ b/paramiko/ssh_gss.py
@@ -405,9 +405,9 @@ class _SSH_SSPI(_SSH_GSSAuth):
         _SSH_GSSAuth.__init__(self, auth_method, gss_deleg_creds)
 
         if self._gss_deleg_creds:
-            self._gss_flags = sspicon.ISC_REQ_INTEGRITY |\
-                              sspicon.ISC_REQ_MUTUAL_AUTH |\
-                              sspicon.ISC_REQ_DELEGATE
+            self._gss_flags = \
+                sspicon.ISC_REQ_INTEGRITY | sspicon.ISC_REQ_MUTUAL_AUTH | \
+                sspicon.ISC_REQ_DELEGATE
         else:
             self._gss_flags = \
                 sspicon.ISC_REQ_INTEGRITY | sspicon.ISC_REQ_MUTUAL_AUTH
@@ -546,11 +546,8 @@ class _SSH_SSPI(_SSH_GSSAuth):
         :return: ``True`` if credentials are delegated, otherwise ``False``
         :rtype: Boolean
         """
-        return (
-                   self._gss_flags & sspicon.ISC_REQ_DELEGATE
-               ) and (
-                   self._gss_srv_ctxt_status or self._gss_flags
-               )
+        return self._gss_flags & sspicon.ISC_REQ_DELEGATE and \
+            (self._gss_srv_ctxt_status or self._gss_flags)
 
     def save_client_creds(self, client_token):
         """