Merge pull request #67 from maxmind/greg/use-f-strings

Clean up string formatting

Author: rafl

minfraud/webservice.py

@@ -29,15 +29,9 @@
 from .validation import validate_report, validate_transaction
 
 
-_AIOHTTP_UA = "minFraud-API/%s %s" % (
-    __version__,
-    aiohttp.http.SERVER_SOFTWARE,
-)
+_AIOHTTP_UA = f"minFraud-API/{__version__} {aiohttp.http.SERVER_SOFTWARE}"
 
-_REQUEST_UA = "minFraud-API/%s %s" % (
-    __version__,
-    requests.utils.default_user_agent(),
-)
+_REQUEST_UA = f"minFraud-API/{__version__} {requests.utils.default_user_agent()}"
 
 
 # pylint: disable=too-many-instance-attributes, missing-class-docstring
@@ -65,7 +59,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self._license_key = license_key
         self._timeout = timeout
 
-        base_uri = u"https://{0:s}/minfraud/v2.0".format(host)
+        base_uri = f"https://{host}/minfraud/v2.0"
         self._score_uri = "/".join([base_uri, "score"])
         self._insights_uri = "/".join([base_uri, "insights"])
         self._factors_uri = "/".join([base_uri, "factors"])
@@ -77,7 +71,7 @@ def _prepare_report(self, request: Dict[str, Any], validate: bool):
             try:
                 validate_report(cleaned_request)
             except MultipleInvalid as ex:
-                raise InvalidRequestError("Invalid report data: {0}".format(ex)) from ex
+                raise InvalidRequestError(f"Invalid report data: {ex}") from ex
         return cleaned_request
 
     def _prepare_transaction(self, request: Dict[str, Any], validate: bool):
@@ -86,9 +80,7 @@ def _prepare_transaction(self, request: Dict[str, Any], validate: bool):
             try:
                 validate_transaction(cleaned_request)
             except MultipleInvalid as ex:
-                raise InvalidRequestError(
-                    "Invalid transaction data: {0}".format(ex)
-                ) from ex
+                raise InvalidRequestError(f"Invalid transaction data: {ex}") from ex
         return cleaned_request
 
     def _copy_and_clean(self, data: Any) -> Any:
@@ -112,9 +104,7 @@ def _handle_success(
             decoded_body = json.loads(body)
         except ValueError as ex:
             raise MinFraudError(
-                "Received a 200 response"
-                " but could not decode the response as "
-                "JSON: {0}".format(body),
+                f"Received a 200 response but could not decode the response as JSON: {body}",
                 200,
                 uri,
             ) from ex
@@ -151,11 +141,11 @@ def _exception_for_4xx_status(
         """Returns exception for error responses with 4xx status codes."""
         if not body:
             return HTTPError(
-                "Received a {0} error with no body".format(status), status, uri, body
+                f"Received a {status} error with no body", status, uri, body
             )
         if content_type.find("json") == -1:
             return HTTPError(
-                "Received a {0} with the following " "body: {1}".format(status, body),
+                f"Received a {status} with the following body: {body}",
                 status,
                 uri,
                 body,
@@ -164,10 +154,7 @@ def _exception_for_4xx_status(
             decoded_body = json.loads(body)
         except ValueError:
             return HTTPError(
-                "Received a {status:d} error but it did not include"
-                " the expected JSON body: {content}".format(
-                    status=status, content=body
-                ),
+                f"Received a {status} error but it did not include the expected JSON body: {body}",
                 status,
                 uri,
                 body,
@@ -178,8 +165,7 @@ def _exception_for_4xx_status(
                     decoded_body.get("error"), decoded_body.get("code"), status, uri
                 )
             return HTTPError(
-                "Error response contains JSON but it does not specify code"
-                " or error keys: {0}".format(body),
+                f"Error response contains JSON but it does not specify code or error keys: {body}",
                 status,
                 uri,
                 body,
@@ -217,7 +203,7 @@ def _exception_for_5xx_status(
     ) -> HTTPError:
         """Returns exception for error response with 5xx status codes."""
         return HTTPError(
-            u"Received a server error ({0}) for " u"{1}".format(status, uri),
+            f"Received a server error ({status}) for {uri}",
             status,
             uri,
             body,
@@ -231,7 +217,7 @@ def _exception_for_unexpected_status(
     ) -> HTTPError:
         """Returns exception for responses with unexpected status codes."""
         return HTTPError(
-            u"Received an unexpected HTTP status " u"({0}) for {1}".format(status, uri),
+            f"Received an unexpected HTTP status ({status}) for {uri}",
             status,
             uri,
             body,

tests/test_models.py

@@ -22,9 +22,7 @@ def test_model_immutability(self):
         ]
         for model in models:
             for attr in (model.attr, "does_not_exist"):
-                with self.assertRaises(
-                    AttributeError, msg="{0!s} - {1}".format(model.obj, attr)
-                ):
+                with self.assertRaises(AttributeError, msg=f"{model.obj} - {attr}"):
                     setattr(model.obj, attr, 5)  # type: ignore
 
     def test_billing_address(self):

tests/test_validation.py

@@ -16,17 +16,15 @@ def setup_transaction(self, transaction):
 
     def check_invalid_transaction(self, transaction):
         self.setup_transaction(transaction)
-        with self.assertRaises(
-            MultipleInvalid, msg="{0!s} is invalid".format(transaction)
-        ):
+        with self.assertRaises(MultipleInvalid, msg=f"{transaction} is invalid"):
             validate_transaction(transaction)
 
     def check_transaction(self, transaction):
         self.setup_transaction(transaction)
         try:
             validate_transaction(transaction)
         except MultipleInvalid as e:
-            self.fail("MultipleInvalid {0} thrown for {1}".format(e.msg, transaction))
+            self.fail(f"MultipleInvalid {e.msg} thrown for {transaction}")
 
     def check_transaction_str_type(self, object, key):
         self.check_transaction({object: {key: "string"}})
@@ -53,15 +51,15 @@ def setup_report(self, report):
 
     def check_invalid_report(self, report):
         self.setup_report(report)
-        with self.assertRaises(MultipleInvalid, msg="{0!s} is invalid".format(report)):
+        with self.assertRaises(MultipleInvalid, msg=f"{report} is invalid"):
             validate_report(report)
 
     def check_report(self, report):
         self.setup_report(report)
         try:
             validate_report(report)
         except MultipleInvalid as e:
-            self.fail("MultipleInvalid {0} thrown for {1}".format(e.msg, report))
+            self.fail(f"MultipleInvalid {e.msg} thrown for {report}")
 
     def check_report_str_type(self, key):
         self.check_report({key: "string"})

tests/test_webservice.py

@@ -48,7 +48,7 @@ def test_invalid_auth(self):
         ):
             with self.assertRaisesRegex(AuthenticationError, "Invalid auth"):
                 self.create_error(
-                    text=u'{{"code":"{0:s}","error":"Invalid auth"}}'.format(error),
+                    text=f'{{"code":"{error}","error":"Invalid auth"}}',
                     status_code=401,
                 )
 
@@ -148,9 +148,7 @@ def create_success(self, text=None, client=None, request=None):
             uri=uri,
             status=204 if self.type == "report" else 200,
             body=self.response if text is None else text,
-            content_type="application/vnd.maxmind.com-minfraud-{0}+json; charset=UTF-8; version=2.0".format(
-                self.type
-            ),
+            content_type=f"application/vnd.maxmind.com-minfraud-{self.type}+json; charset=UTF-8; version=2.0",
         )
         if client is None:
             client = self.client