Simplify RequestsFetcher.fetch()

Make the internal function chunks() a separate
private method of Reqests fetcher.

Signed-off-by: Teodora Sechkova <tsechkova@vmware.com>

Author: sechkova

tuf/ngclient/_internal/requests_fetcher.py

@@ -21,7 +21,7 @@
 # Globals
 logger = logging.getLogger(__name__)
 
-# Classess
+# Classes
 class RequestsFetcher(FetcherInterface):
     """A concrete implementation of FetcherInterface based on the Requests
     library.
@@ -90,58 +90,59 @@ def fetch(self, url, required_length):
             status = e.response.status_code
             raise exceptions.FetcherHTTPError(str(e), status)
 
-        # Define a generator function to be returned by fetch. This way the
-        # caller of fetch can differentiate between connection and actual data
-        # download and measure download times accordingly.
-        def chunks():
-            try:
-                bytes_received = 0
-                while True:
-                    # We download a fixed chunk of data in every round. This is
-                    # so that we can defend against slow retrieval attacks.
-                    # Furthermore, we do not wish to download an extremely
-                    # large file in one shot. Before beginning the round, sleep
-                    # (if set) for a short amount of time so that the CPU is not
-                    # hogged in the while loop.
-                    if self.sleep_before_round:
-                        time.sleep(self.sleep_before_round)
-
-                    read_amount = min(
-                        self.chunk_size,
-                        required_length - bytes_received,
-                    )
-
-                    # NOTE: This may not handle some servers adding a
-                    # Content-Encoding header, which may cause urllib3 to
-                    #  misbehave:
-                    # https://github.com/pypa/pip/blob/404838abcca467648180b358598c597b74d568c9/src/pip/_internal/download.py#L547-L582
-                    data = response.raw.read(read_amount)
-                    bytes_received += len(data)
+        return self._chunks(response, required_length)
 
-                    # We might have no more data to read. Check number of bytes
-                    # downloaded.
-                    if not data:
-                        logger.debug(
-                            "Downloaded %d out of %d bytes",
-                            bytes_received,
-                            required_length,
-                        )
+    def _chunks(self, response, required_length):
+        """A generator function to be returned by fetch. This way the
+        caller of fetch can differentiate between connection and actual data
+        download."""
 
-                        # Finally, we signal that the download is complete.
-                        break
+        try:
+            bytes_received = 0
+            while True:
+                # We download a fixed chunk of data in every round. This is
+                # so that we can defend against slow retrieval attacks.
+                # Furthermore, we do not wish to download an extremely
+                # large file in one shot. Before beginning the round, sleep
+                # (if set) for a short amount of time so that the CPU is not
+                # hogged in the while loop.
+                if self.sleep_before_round:
+                    time.sleep(self.sleep_before_round)
+
+                read_amount = min(
+                    self.chunk_size,
+                    required_length - bytes_received,
+                )
+
+                # NOTE: This may not handle some servers adding a
+                # Content-Encoding header, which may cause urllib3 to
+                #  misbehave:
+                # https://github.com/pypa/pip/blob/404838abcca467648180b358598c597b74d568c9/src/pip/_internal/download.py#L547-L582
+                data = response.raw.read(read_amount)
+                bytes_received += len(data)
+
+                # We might have no more data to read. Check number of bytes
+                # downloaded.
+                if not data:
+                    logger.debug(
+                        "Downloaded %d out of %d bytes",
+                        bytes_received,
+                        required_length,
+                    )
 
-                    yield data
+                    # Finally, we signal that the download is complete.
+                    break
 
-                    if bytes_received >= required_length:
-                        break
+                yield data
 
-            except urllib3.exceptions.ReadTimeoutError as e:
-                raise exceptions.SlowRetrievalError(str(e))
+                if bytes_received >= required_length:
+                    break
 
-            finally:
-                response.close()
+        except urllib3.exceptions.ReadTimeoutError as e:
+            raise exceptions.SlowRetrievalError(str(e))
 
-        return chunks()
+        finally:
+            response.close()
 
     def _get_session(self, url):
         """Returns a different customized requests.Session per schema+hostname