fixed the formatting issues causing ci failure

Author: Nikhil172913832

sdk/core/azure-core/azure/core/pipeline/policies/_universal.py

@@ -75,7 +75,9 @@ class HeadersPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
             :caption: Configuring a headers policy.
     """
 
-    def __init__(self, base_headers: Optional[Dict[str, str]] = None, **kwargs: Any) -> None:
+    def __init__(
+        self, base_headers: Optional[Dict[str, str]] = None, **kwargs: Any
+    ) -> None:
         self._headers: Dict[str, str] = base_headers or {}
         self._headers.update(kwargs.pop("headers", {}))
 
@@ -227,7 +229,9 @@ def user_agent(self) -> str:
         :rtype: str
         """
         if self.use_env:
-            add_user_agent_header = os.environ.get(self._ENV_ADDITIONAL_USER_AGENT, None)
+            add_user_agent_header = os.environ.get(
+                self._ENV_ADDITIONAL_USER_AGENT, None
+            )
             if add_user_agent_header is not None:
                 return "{} {}".format(self._user_agent, add_user_agent_header)
         return self._user_agent
@@ -276,7 +280,9 @@ class NetworkTraceLoggingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTy
             :caption: Configuring a network trace logging policy.
     """
 
-    def __init__(self, logging_enable: bool = False, **kwargs: Any):  # pylint: disable=unused-argument
+    def __init__(
+        self, logging_enable: bool = False, **kwargs: Any
+    ):  # pylint: disable=unused-argument
         self.enable_http_logger = logging_enable
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
@@ -354,7 +360,9 @@ def on_response(
                 if header and pattern.match(header):
                     filename = header.partition("=")[2]
                     log_string += "\nFile attachments: {}".format(filename)
-                elif http_response.headers.get("content-type", "").endswith("octet-stream"):
+                elif http_response.headers.get("content-type", "").endswith(
+                    "octet-stream"
+                ):
                     log_string += "\nBody contains binary data."
                 elif http_response.headers.get("content-type", "").startswith("image"):
                     log_string += "\nBody contains image data."
@@ -427,19 +435,41 @@ class HttpLoggingPolicy(
     REDACTED_PLACEHOLDER: str = "REDACTED"
     MULTI_RECORD_LOG: str = "AZURE_SDK_LOGGING_MULTIRECORD"
 
-    def __init__(self, logger: Optional[logging.Logger] = None, *, logging_level: int = logging.INFO, **kwargs: Any):  # pylint: disable=unused-argument
-        self.logger: logging.Logger = logger or logging.getLogger("azure.core.pipeline.policies.http_logging_policy")
+    def __init__(
+        self,
+        logger: Optional[logging.Logger] = None,
+        *,
+        logging_level: int = logging.INFO,
+        **kwargs: Any
+    ):  # pylint: disable=unused-argument
+        self.logger: logging.Logger = logger or logging.getLogger(
+            "azure.core.pipeline.policies.http_logging_policy"
+        )
         self.logging_level: int = logging_level
         self.allowed_query_params: Set[str] = set()
-        self.allowed_header_names: Set[str] = set(self.__class__.DEFAULT_HEADERS_ALLOWLIST)
+        self.allowed_header_names: Set[str] = set(
+            self.__class__.DEFAULT_HEADERS_ALLOWLIST
+        )
 
     def _redact_query_param(self, key: str, value: str) -> str:
-        lower_case_allowed_query_params = [param.lower() for param in self.allowed_query_params]
-        return value if key.lower() in lower_case_allowed_query_params else HttpLoggingPolicy.REDACTED_PLACEHOLDER
+        lower_case_allowed_query_params = [
+            param.lower() for param in self.allowed_query_params
+        ]
+        return (
+            value
+            if key.lower() in lower_case_allowed_query_params
+            else HttpLoggingPolicy.REDACTED_PLACEHOLDER
+        )
 
     def _redact_header(self, key: str, value: str) -> str:
-        lower_case_allowed_header_names = [header.lower() for header in self.allowed_header_names]
-        return value if key.lower() in lower_case_allowed_header_names else HttpLoggingPolicy.REDACTED_PLACEHOLDER
+        lower_case_allowed_header_names = [
+            header.lower() for header in self.allowed_header_names
+        ]
+        return (
+            value
+            if key.lower() in lower_case_allowed_header_names
+            else HttpLoggingPolicy.REDACTED_PLACEHOLDER
+        )
 
     def on_request(  # pylint: disable=too-many-return-statements
         self, request: PipelineRequest[HTTPRequestType]
@@ -454,23 +484,29 @@ def on_request(  # pylint: disable=too-many-return-statements
         # Get logger in my context first (request has been retried)
         # then read from kwargs (pop if that's the case)
         # then use my instance logger
-        logger = request.context.setdefault("logger", options.pop("logger", self.logger))
+        logger = request.context.setdefault(
+            "logger", options.pop("logger", self.logger)
+        )
 
         if not logger.isEnabledFor(self.logging_level):
             return
 
         try:
             parsed_url = list(urllib.parse.urlparse(http_request.url))
             parsed_qp = urllib.parse.parse_qsl(parsed_url[4], keep_blank_values=True)
-            filtered_qp = [(key, self._redact_query_param(key, value)) for key, value in parsed_qp]
+            filtered_qp = [
+                (key, self._redact_query_param(key, value)) for key, value in parsed_qp
+            ]
             # 4 is query
             parsed_url[4] = "&".join(["=".join(part) for part in filtered_qp])
             redacted_url = urllib.parse.urlunparse(parsed_url)
 
             multi_record = os.environ.get(HttpLoggingPolicy.MULTI_RECORD_LOG, False)
             if multi_record:
                 logger.log(self.logging_level, "Request URL: %r", redacted_url)
-                logger.log(self.logging_level, "Request method: %r", http_request.method)
+                logger.log(
+                    self.logging_level, "Request method: %r", http_request.method
+                )
                 logger.log(self.logging_level, "Request headers:")
                 for header, value in http_request.headers.items():
                     value = self._redact_header(header, value)
@@ -535,15 +571,19 @@ def on_response(
         # then use my instance logger
         # If on_request was called, should always read from context
         options = request.context.options
-        logger = request.context.setdefault("logger", options.pop("logger", self.logger))
+        logger = request.context.setdefault(
+            "logger", options.pop("logger", self.logger)
+        )
 
         try:
             if not logger.isEnabledFor(self.logging_level):
                 return
 
             multi_record = os.environ.get(HttpLoggingPolicy.MULTI_RECORD_LOG, False)
             if multi_record:
-                logger.log(self.logging_level, "Response status: %r", http_response.status_code)
+                logger.log(
+                    self.logging_level, "Response status: %r", http_response.status_code
+                )
                 logger.log(self.logging_level, "Response headers:")
                 for res_header, value in http_response.headers.items():
                     value = self._redact_header(res_header, value)
@@ -573,7 +613,9 @@ class ContentDecodePolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
     CONTEXT_NAME = "deserialized_data"
 
     def __init__(
-        self, response_encoding: Optional[str] = None, **kwargs: Any  # pylint: disable=unused-argument
+        self,
+        response_encoding: Optional[str] = None,
+        **kwargs: Any  # pylint: disable=unused-argument
     ) -> None:
         self._response_encoding = response_encoding
 
@@ -690,7 +732,9 @@ def deserialize_from_http_generics(
             # even if it's likely dead code
             if not inspect.iscoroutinefunction(response.read):  # type: ignore
                 response.read()  # type: ignore
-        return cls.deserialize_from_text(response.text(encoding), mime_type, response=response)
+        return cls.deserialize_from_text(
+            response.text(encoding), mime_type, response=response
+        )
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
         """Set the response encoding in the request context.

sdk/core/azure-core/tests/async_tests/test_http_logging_policy_async.py

@@ -16,7 +16,9 @@
 from utils import HTTP_RESPONSES, request_and_responses_product, create_http_response
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):
@@ -114,11 +116,16 @@ def emit(self, record):
     assert len(mock_handler.messages) == 2
     messages_request = mock_handler.messages[0].message.split("\n")
     messages_response = mock_handler.messages[1].message.split("\n")
-    assert messages_request[0] == "Request URL: 'http://localhost/?country=france&city=REDACTED'"
+    assert (
+        messages_request[0]
+        == "Request URL: 'http://localhost/?country=france&city=REDACTED'"
+    )
     assert messages_request[1] == "Request method: 'GET'"
     assert messages_request[2] == "Request headers:"
     # Dict not ordered in Python, exact logging order doesn't matter
-    assert set([messages_request[3], messages_request[4]]) == set(["    'Accept': 'Caramel'", "    'Hate': 'REDACTED'"])
+    assert set([messages_request[3], messages_request[4]]) == set(
+        ["    'Accept': 'Caramel'", "    'Hate': 'REDACTED'"]
+    )
     assert messages_request[5] == "No body was attached to the request"
     assert messages_response[0] == "Response status: 202"
     assert messages_response[1] == "Response headers:"
@@ -130,7 +137,9 @@ def emit(self, record):
     mock_handler.reset()
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger_operation_level(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):
@@ -210,7 +219,9 @@ def emit(self, record):
     mock_handler.reset()
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger_with_body(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):
@@ -255,7 +266,9 @@ def emit(self, record):
     mock_handler.reset()
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger_with_custom_log_level(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):
@@ -299,8 +312,12 @@ def emit(self, record):
     mock_handler.reset()
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
-@pytest.mark.skipif(sys.version_info < (3, 6), reason="types.AsyncGeneratorType does not exist in 3.5")
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
+@pytest.mark.skipif(
+    sys.version_info < (3, 6), reason="types.AsyncGeneratorType does not exist in 3.5"
+)
 def test_http_logger_with_generator_body(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):

sdk/core/azure-core/tests/test_http_logging_policy.py

@@ -19,7 +19,9 @@
 from azure.core.pipeline._tools import is_rest
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):
@@ -119,11 +121,16 @@ def emit(self, record):
     assert len(mock_handler.messages) == 2
     messages_request = mock_handler.messages[0].message.split("\n")
     messages_response = mock_handler.messages[1].message.split("\n")
-    assert messages_request[0] == "Request URL: 'http://localhost/?country=france&city=REDACTED'"
+    assert (
+        messages_request[0]
+        == "Request URL: 'http://localhost/?country=france&city=REDACTED'"
+    )
     assert messages_request[1] == "Request method: 'GET'"
     assert messages_request[2] == "Request headers:"
     # Dict not ordered in Python, exact logging order doesn't matter
-    assert set([messages_request[3], messages_request[4]]) == set(["    'Accept': 'Caramel'", "    'Hate': 'REDACTED'"])
+    assert set([messages_request[3], messages_request[4]]) == set(
+        ["    'Accept': 'Caramel'", "    'Hate': 'REDACTED'"]
+    )
     assert messages_request[5] == "No body was attached to the request"
     assert messages_response[0] == "Response status: 202"
     assert messages_response[1] == "Response headers:"
@@ -135,7 +142,9 @@ def emit(self, record):
     mock_handler.reset()
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger_operation_level(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):
@@ -215,7 +224,9 @@ def emit(self, record):
     mock_handler.reset()
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger_with_body(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):
@@ -260,7 +271,9 @@ def emit(self, record):
     mock_handler.reset()
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger_with_custom_log_level(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):
@@ -304,7 +317,9 @@ def emit(self, record):
     mock_handler.reset()
 
 
-@pytest.mark.parametrize("http_request,http_response", request_and_responses_product(HTTP_RESPONSES))
+@pytest.mark.parametrize(
+    "http_request,http_response", request_and_responses_product(HTTP_RESPONSES)
+)
 def test_http_logger_with_generator_body(http_request, http_response):
     class MockHandler(logging.Handler):
         def __init__(self):