style: f-strings and logging interpolation

Author: drts01

qualysapi/api_actions.py

@@ -23,7 +23,7 @@ def getHost(self, host):
 
     def getHostRange(self, start, end):
         call = "/api/2.0/fo/asset/host/"
-        parameters = {"action": "list", "ips": start + "-" + end}
+        parameters = {"action": "list", "ips": f"{start}-{end}"}
         hostData = objectify.fromstring(self.request(call, parameters).encode("utf-8"))
         hostArray = []
         for host in hostData.RESPONSE.HOST_LIST.HOST:
@@ -78,7 +78,7 @@ def listAssetGroups(self, groupName=""):
             agData = objectify.fromstring(self.request(call).encode("utf-8"))
         else:
             agData = objectify.fromstring(
-                self.request(call, "title=" + groupName).encode("utf-8")
+                self.request(call, f"title={groupName}").encode("utf-8")
             )
 
         groupsArray = []

qualysapi/api_methods.py

@@ -100,7 +100,7 @@
 for auth_type in set(
     ["ibm_db2", "ms_sql", "oracle", "oracle_listener", "snmp", "unix", "windows",]
 ):
-    api_methods["2"].add("api/2.0/fo/auth/%s/" % auth_type)
+    api_methods["2"].add(f"api/2.0/fo/auth/{auth_type}/")
 # WAS GET methods when no POST data.
 api_methods["was no data get"] = set(
     [

qualysapi/config.py

@@ -60,7 +60,7 @@ def __init__(
 
             # apply bitmask to current mode to check ONLY user access permissions.
             if (mode & (stat.S_IRWXG | stat.S_IRWXO)) != 0:
-                logger.warning("%s permissions allows more than user access." % (filename,))
+                logger.warning("%s permissions allows more than user access.", filename)
 
             self._cfgparse.read(self._cfgfile)
 
@@ -136,9 +136,10 @@ def __init__(
                     proxy_port_url = proxy_port
                     proxy_port = self._cfgparse.get("proxy", "proxy_port")
                     logger.warning(
-                        "Proxy port from url overwritten by specified proxy_port from config:"
+                        "Proxy port from url overwritten by specified proxy_port from config: %s --> %s",
+                        proxy_port_url,
+                        proxy_port,
                     )
-                    logger.warning("%s --> %s" % (proxy_port_url, proxy_port))
                 else:
                     proxy_port = self._cfgparse.get("proxy", "proxy_port")
             if not proxy_port:
@@ -169,10 +170,10 @@ def __init__(
             proxy_config = proxy_url
             if proxy_port:
                 # Proxy port requested.
-                proxy_config += ":" + proxy_port
+                proxy_config += f":{proxy_port}"
             if proxy_username:
                 # Proxy authentication requested.
-                proxy_config = proxy_username + ":" + proxy_password + "@" + proxy_config
+                proxy_config = f"{proxy_username}:{proxy_password}@{proxy_config}"
             # Prefix by proxy protocol.
             proxy_config = proxy_protocol + proxy_config
         # Set up proxy if applicable.

qualysapi/connector.py

@@ -55,9 +55,9 @@ def __init__(self, auth, server="qualysapi.qualys.com", proxies=None, max_retrie
             qualysapi.api_methods.api_methods_with_trailing_slash
         )
         self.proxies = proxies
-        logger.debug("proxies = \n%s" % proxies)
+        logger.debug("proxies = \n%s", proxies)
         # Set up requests max_retries.
-        logger.debug("max_retries = \n%s" % max_retries)
+        logger.debug("max_retries = \n%s", max_retries)
         self.session = requests.Session()
         http_max_retries = requests.adapters.HTTPAdapter(max_retries=max_retries)
         https_max_retries = requests.adapters.HTTPAdapter(max_retries=max_retries)
@@ -120,22 +120,22 @@ def url_api_version(self, api_version):
         # Set base url depending on API version.
         if api_version == 1:
             # QualysGuard API v1 url.
-            url = "https://%s/msp/" % (self.server,)
+            url = f"https://{self.server}/msp/"
         elif api_version == 2:
             # QualysGuard API v2 url.
-            url = "https://%s/" % (self.server,)
+            url = f"https://{self.server}/"
         elif api_version == "was":
             # QualysGuard REST v3 API url (Portal API).
-            url = "https://%s/qps/rest/3.0/" % (self.server,)
+            url = f"https://{self.server}/qps/rest/3.0/"
         elif api_version == "am":
             # QualysGuard REST v1 API url (Portal API).
-            url = "https://%s/qps/rest/1.0/" % (self.server,)
+            url = f"https://{self.server}/qps/rest/1.0/"
         elif api_version == "am2":
             # QualysGuard REST v1 API url (Portal API).
-            url = "https://%s/qps/rest/2.0/" % (self.server,)
+            url = f"https://{self.server}/qps/rest/2.0/"
         else:
-            raise Exception("Unknown QualysGuard API Version Number (%s)" % (api_version,))
-        logger.debug("Base url =\n%s" % (url))
+            raise Exception(f"Unknown QualysGuard API Version Number {api_version}")
+        logger.debug("Base url =\n%s", url)
         return url
 
     def format_http_method(self, api_version, api_call, data):
@@ -185,7 +185,7 @@ def preformat_call(self, api_call):
         api_call_formatted = api_call_formatted.rstrip("?")
         if api_call != api_call_formatted:
             # Show difference
-            logger.debug("api_call post strip =\n%s" % api_call_formatted)
+            logger.debug("api_call post strip =\n%s", api_call_formatted)
         return api_call_formatted
 
     def format_call(self, api_version, api_call):
@@ -195,7 +195,7 @@ def format_call(self, api_version, api_call):
         # Remove possible starting slashes or trailing question marks in call.
         api_call = api_call.lstrip("/")
         api_call = api_call.rstrip("?")
-        logger.debug("api_call post strip =\n%s" % api_call)
+        logger.debug("api_call post strip =\n%s", api_call)
         # Make sure call always ends in slash for API v2 calls.
         if api_version == 2 and api_call[-1] != "/":
             # Add slash.
@@ -216,25 +216,25 @@ def format_payload(self, api_version, data):
             # Check if string type.
             if type(data) == str:
                 # Convert to dictionary.
-                logger.debug("Converting string to dict:\n%s" % data)
+                logger.debug("Converting string to dict:\n%s", data)
                 # Remove possible starting question mark & ending ampersands.
                 data = data.lstrip("?")
                 data = data.rstrip("&")
                 # Convert to dictionary.
                 data = parse_qs(data)
-                logger.debug("Converted:\n%s" % str(data))
+                logger.debug("Converted:\n%s", str(data))
         elif api_version in ("am", "was", "am2"):
             if type(data) == etree._Element:
                 logger.debug("Converting lxml.builder.E to string")
                 data = etree.tostring(data)
-                logger.debug("Converted:\n%s" % data)
+                logger.debug("Converted:\n%s", data)
         return data
 
     def build_request(self, api_call, data=None, api_version=None, http_method=None):
-        logger.debug("api_call =\n%s" % api_call)
-        logger.debug("api_version =\n%s" % api_version)
-        logger.debug("data %s =\n %s" % (type(data), str(data)))
-        logger.debug("http_method =\n%s" % http_method)
+        logger.debug("api_call =\n%s", api_call)
+        logger.debug("api_version =\n%s", api_version)
+        logger.debug("data %s =\n %s", type(data), str(data))
+        logger.debug("http_method =\n%s", http_method)
 
         #
         # Determine API version.
@@ -252,32 +252,31 @@ def build_request(self, api_call, data=None, api_version=None, http_method=None)
         #
         # Set up headers.
         headers = {
-            "X-Requested-With": "Parag Baxi QualysAPI (python) v%s"
-            % (qualysapi.version.__version__,)
+            "X-Requested-With": f"Parag Baxi QualysAPI (python) v{qualysapi.version.__version__}"
         }
-        logger.debug("headers =\n%s" % (str(headers)))
+        logger.debug("headers =\n%s", str(headers))
         # Portal API takes in XML text, requiring custom header.
         if api_version in ("am", "was", "am2"):
             headers["Content-type"] = "text/xml"
         #
         # Set up http request method, if not specified.
         if not http_method:
             http_method = self.format_http_method(api_version, api_call, data)
-        logger.debug("http_method =\n%s" % http_method)
+        logger.debug("http_method =\n%s", http_method)
         #
         # Format API call.
         api_call = self.format_call(api_version, api_call)
-        logger.debug("api_call =\n%s" % (api_call))
+        logger.debug("api_call =\n%s", api_call)
         # Append api_call to url.
         url += api_call
         #
         # Format data, if applicable.
         if data is not None:
             data = self.format_payload(api_version, data)
 
-        logger.debug("url =\n%s" % (str(url)))
-        logger.debug("data =\n%s" % (str(data)))
-        logger.debug("headers =\n%s" % (str(headers)))
+        logger.debug("url =\n%s", str(url))
+        logger.debug("data =\n%s", str(data))
+        logger.debug("headers =\n%s", str(headers))
 
         return url, data, headers
 
@@ -313,19 +312,18 @@ def request_streaming(
                 stream=True,
                 verify=verify,
             )
-        logger.debug("response headers =\n%s" % (str(request.headers)))
+        logger.debug("response headers =\n%s", str(request.headers))
         #
         # Remember how many times left user can make against api_call.
         try:
             self.rate_limit_remaining[api_call] = int(request.headers["x-ratelimit-remaining"])
             logger.debug(
-                "rate limit for api_call, %s = %s"
-                % (api_call, self.rate_limit_remaining[api_call])
+                "rate limit for api_call, %s = %s", api_call, self.rate_limit_remaining[api_call]
             )
             if self.rate_limit_remaining[api_call] <= 0:
                 logger.critical(
-                    "ATTENTION! RATE LIMIT HAS BEEN REACHED (remaining api calls = %s)!"
-                    % self.rate_limit_remaining[api_call]
+                    "ATTENTION! RATE LIMIT HAS BEEN REACHED (remaining api calls = %s)!",
+                    self.rate_limit_remaining[api_call],
                 )
         except KeyError as e:
             # Likely a bad api_call.
@@ -353,8 +351,8 @@ def request(
 
         """
 
-        logger.debug("concurrent_scans_retries =\n%s" % str(concurrent_scans_retries))
-        logger.debug("concurrent_scans_retry_delay =\n%s" % str(concurrent_scans_retry_delay))
+        logger.debug("concurrent_scans_retries =\n%s", str(concurrent_scans_retries))
+        logger.debug("concurrent_scans_retry_delay =\n%s", str(concurrent_scans_retry_delay))
         concurrent_scans_retries = int(concurrent_scans_retries)
         concurrent_scans_retry_delay = int(concurrent_scans_retry_delay)
 
@@ -367,9 +365,9 @@ def request(
         rate_warn_threshold = 10
         while retries <= concurrent_scans_retries:
             # Make request.
-            logger.debug("url =\n%s" % (str(url)))
-            logger.debug("data =\n%s" % (str(data)))
-            logger.debug("headers =\n%s" % (str(headers)))
+            logger.debug("url =\n%s", str(url))
+            logger.debug("data =\n%s", str(data))
+            logger.debug("headers =\n%s", str(headers))
             if http_method == "get":
                 # GET
                 logger.debug("GET request.")
@@ -393,7 +391,7 @@ def request(
                     proxies=self.proxies,
                     verify=verify,
                 )
-            logger.debug("response headers =\n%s" % (str(request.headers)))
+            logger.debug("response headers =\n%s", str(request.headers))
             # Force request encoding value, the automatic detection is very long for large files (report for example)
             # And sometimes with MemoryError
             if request.encoding is None:
@@ -405,25 +403,27 @@ def request(
                     request.headers["x-ratelimit-remaining"]
                 )
                 logger.debug(
-                    "rate limit for api_call, %s = %s"
-                    % (api_call, self.rate_limit_remaining[api_call])
+                    "rate limit for api_call, %s = %s",
+                    api_call,
+                    self.rate_limit_remaining[api_call],
                 )
                 if self.rate_limit_remaining[api_call] > rate_warn_threshold:
                     logger.debug(
-                        "rate limit for api_call, %s = %s"
-                        % (api_call, self.rate_limit_remaining[api_call])
+                        "rate limit for api_call, %s = %s",
+                        api_call,
+                        self.rate_limit_remaining[api_call],
                     )
                 elif (self.rate_limit_remaining[api_call] <= rate_warn_threshold) and (
                     self.rate_limit_remaining[api_call] > 0
                 ):
                     logger.warning(
-                        "Rate limit is about to being reached (remaining api calls = %s)"
-                        % self.rate_limit_remaining[api_call]
+                        "Rate limit is about to being reached (remaining api calls = %s)",
+                        self.rate_limit_remaining[api_call],
                     )
                 elif self.rate_limit_remaining[api_call] <= 0:
                     logger.critical(
-                        "ATTENTION! RATE LIMIT HAS BEEN REACHED (remaining api calls = %s)!"
-                        % self.rate_limit_remaining[api_call]
+                        "ATTENTION! RATE LIMIT HAS BEEN REACHED (remaining api calls = %s)!",
+                        self.rate_limit_remaining[api_call],
                     )
             except KeyError as e:
                 # Likely a bad api_call.
@@ -435,7 +435,7 @@ def request(
                 pass
             # Response received.
             response = request.text
-            logger.debug("response text =\n%s" % (response))
+            logger.debug("response text =\n%s", response)
             # Keep track of how many retries.
             retries += 1
             # Check for concurrent scans limit.
@@ -454,11 +454,11 @@ def request(
                 # If trying again, delay next try by concurrent_scans_retry_delay.
                 if retries <= concurrent_scans_retries:
                     logger.warning(
-                        "Waiting %d seconds until next try." % concurrent_scans_retry_delay
+                        "Waiting %d seconds until next try.", concurrent_scans_retry_delay
                     )
                     time.sleep(concurrent_scans_retry_delay)
                     # Inform user of how many retries.
-                    logger.critical("Retry #%d" % retries)
+                    logger.critical("Retry #%d", retries)
                 else:
                     # Ran out of retries. Let user know.
                     print("Alert! Ran out of concurrent_scans_retries!")
@@ -471,17 +471,17 @@ def request(
             # Error
             print("Error! Received a 4XX client error or 5XX server error response.")
             print("Content = \n", response)
-            logger.error("Content = \n%s" % response)
+            logger.error("Content = \n%s", response)
             print("Headers = \n", request.headers)
-            logger.error("Headers = \n%s" % str(request.headers))
+            logger.error("Headers = \n%s", str(request.headers))
             request.raise_for_status()
         if '<RETURN status="FAILED" number="2007">' in response:
             print(
                 "Error! Your IP address is not in the list of secure IPs. Manager must include this IP (QualysGuard VM > Users > Security)."
             )
             print("Content = \n", response)
-            logger.error("Content = \n%s" % response)
+            logger.error("Content = \n%s", response)
             print("Headers = \n", request.headers)
-            logger.error("Headers = \n%s" % str(request.headers))
+            logger.error("Headers = \n%s", str(request.headers))
             return False
         return response

setup.py

@@ -9,9 +9,9 @@
 SETUPTOOLS_VER = "30.5.0"  # Minimum version that supports pyproject.toml
 
 try:
-    require("setuptools>=" + SETUPTOOLS_VER)
+    require(f"setuptools>={SETUPTOOLS_VER}")
 except VersionConflict:
-    sys.exit("Error: version of setuptools is too old (<{})!".format(SETUPTOOLS_VER))
+    sys.exit(f"Error: version of setuptools is too old (<{SETUPTOOLS_VER})!")
 
 __author__ = "Parag Baxi <[email protected]>"
 __copyright__ = "Copyright 2011-2018, Parag Baxi"