[Tables] Enable to run black in ci (Azure#31306)

Author: Yalin Li

sdk/tables/azure-data-tables/azure/__init__.py

@@ -1 +1 @@
-__path__ = __import__('pkgutil').extend_path(__path__, __name__)  # type: ignore
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore

sdk/tables/azure-data-tables/azure/data/__init__.py

@@ -1 +1 @@
-__path__ = __import__('pkgutil').extend_path(__path__, __name__)  # type: ignore
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)  # type: ignore

sdk/tables/azure-data-tables/azure/data/tables/__init__.py

@@ -20,7 +20,7 @@
     TableItem,
     ResourceTypes,
     AccountSasPermissions,
-    TransactionOperation
+    TransactionOperation,
 )
 from ._version import VERSION
 

sdk/tables/azure-data-tables/azure/data/tables/_authentication.py

@@ -20,7 +20,7 @@
     AsyncHttpTransport = None  # type: ignore
 
 try:
-    from yarl import URL # cspell:disable-line
+    from yarl import URL  # cspell:disable-line
 except ImportError:
     pass
 
@@ -88,9 +88,7 @@ def __init__(self, credential, is_emulated=False):
         self.is_emulated = is_emulated
 
     def _get_headers(self, request, headers_to_sign):
-        headers = dict(
-            (name.lower(), value) for name, value in request.headers.items() if value
-        )
+        headers = dict((name.lower(), value) for name, value in request.headers.items() if value)
         if "content-length" in headers and headers["content-length"] == "0":
             del headers["content-length"]
         return "\n".join(headers.get(x, "") for x in headers_to_sign) + "\n"
@@ -187,7 +185,7 @@ def __init__(
         *scopes: str,
         discover_tenant: bool = True,
         discover_scopes: bool = True,
-        **kwargs
+        **kwargs,
     ) -> None:
         self._discover_tenant = discover_tenant
         self._discover_scopes = discover_scopes
@@ -228,43 +226,33 @@ def on_challenge(self, request: PipelineRequest, response: PipelineResponse) ->
 def _configure_credential(credential: AzureNamedKeyCredential) -> SharedKeyCredentialPolicy:
     ...
 
+
 @overload
 def _configure_credential(credential: SharedKeyCredentialPolicy) -> SharedKeyCredentialPolicy:
     ...
 
+
 @overload
 def _configure_credential(credential: AzureSasCredential) -> AzureSasCredentialPolicy:
     ...
 
+
 @overload
 def _configure_credential(credential: TokenCredential) -> BearerTokenChallengePolicy:
     ...
 
+
 @overload
 def _configure_credential(credential: None) -> None:
     ...
 
+
 def _configure_credential(
-    credential: Optional[
-        Union[
-            AzureNamedKeyCredential,
-            AzureSasCredential,
-            TokenCredential,
-            SharedKeyCredentialPolicy
-        ]
-    ]
-) -> Optional[
-    Union[
-        BearerTokenChallengePolicy,
-        AzureSasCredentialPolicy,
-        SharedKeyCredentialPolicy
-    ]
-]:
+    credential: Optional[Union[AzureNamedKeyCredential, AzureSasCredential, TokenCredential, SharedKeyCredentialPolicy]]
+) -> Optional[Union[BearerTokenChallengePolicy, AzureSasCredentialPolicy, SharedKeyCredentialPolicy]]:
     if hasattr(credential, "get_token"):
         credential = cast(TokenCredential, credential)
-        return BearerTokenChallengePolicy(
-            credential, STORAGE_OAUTH_SCOPE
-        )
+        return BearerTokenChallengePolicy(credential, STORAGE_OAUTH_SCOPE)
     if isinstance(credential, SharedKeyCredentialPolicy):
         return credential
     if isinstance(credential, AzureSasCredential):

sdk/tables/azure-data-tables/azure/data/tables/_base_client.py

@@ -7,6 +7,7 @@
 
 from uuid import uuid4
 from typing import Any, Dict, List, Optional, Mapping, Union
+
 try:
     from urllib.parse import parse_qs, quote, urlparse
 except ImportError:
@@ -38,12 +39,7 @@
     DEFAULT_COSMOS_ENDPOINT_SUFFIX,
     DEFAULT_STORAGE_ENDPOINT_SUFFIX,
 )
-from ._error import (
-    RequestTooLargeError,
-    TableTransactionError,
-    _decode_error,
-    _validate_tablename_error
-)
+from ._error import RequestTooLargeError, TableTransactionError, _decode_error, _validate_tablename_error
 from ._models import LocationMode
 from ._authentication import _configure_credential
 from ._policies import (
@@ -56,16 +52,14 @@
 
 _SUPPORTED_API_VERSIONS = ["2019-02-02", "2019-07-07", "2020-12-06"]
 # cspell:disable-next-line
-_DEV_CONN_STRING = "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1" # pylint: disable=line-too-long
+_DEV_CONN_STRING = "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1"  # pylint: disable=line-too-long
 
 
 def get_api_version(kwargs: Dict[str, Any], default: str) -> str:
     api_version = kwargs.pop("api_version", None)
     if api_version and api_version not in _SUPPORTED_API_VERSIONS:
         versions = "\n".join(_SUPPORTED_API_VERSIONS)
-        raise ValueError(
-            f"Unsupported API version '{api_version}'. Please select from:\n{versions}"
-        )
+        raise ValueError(f"Unsupported API version '{api_version}'. Please select from:\n{versions}")
     return api_version or default
 
 
@@ -74,7 +68,7 @@ def __init__(
         self,
         account_url: str,
         credential: Optional[Union[AzureNamedKeyCredential, AzureSasCredential, TokenCredential]] = None,
-        **kwargs
+        **kwargs,
     ) -> None:
         try:
             if not account_url.lower().startswith("http"):
@@ -87,9 +81,7 @@ def __init__(
 
         _, sas_token = parse_query(parsed_url.query)
         if not sas_token and not credential:
-            raise ValueError(
-                "You need to provide either an AzureSasCredential or AzureNamedKeyCredential"
-            )
+            raise ValueError("You need to provide either an AzureSasCredential or AzureNamedKeyCredential")
         self._query_str, credential = format_query_string(sas_token, credential)
         self._location_mode = kwargs.get("location_mode", LocationMode.PRIMARY)
         self._hosts = kwargs.get("_hosts")
@@ -115,17 +107,15 @@ def __init__(
         if self.scheme.lower() != "https" and hasattr(self.credential, "get_token"):
             raise ValueError("Token credential is only supported with HTTPS.")
         if hasattr(self.credential, "named_key"):
-            self.account_name = self.credential.named_key.name # type: ignore
+            self.account_name = self.credential.named_key.name  # type: ignore
             endpoint_suffix = os.getenv("TABLES_STORAGE_ENDPOINT_SUFFIX", DEFAULT_STORAGE_ENDPOINT_SUFFIX)
             secondary_hostname = f"{self.account_name}-secondary.table.{endpoint_suffix}"
 
         if not self._hosts:
             if len(account) > 1:
                 secondary_hostname = parsed_url.netloc.replace(
                     account[0], account[0] + "-secondary"
-                ) + parsed_url.path.replace(
-                    account[0], account[0] + "-secondary"
-                ).rstrip("/")
+                ) + parsed_url.path.replace(account[0], account[0] + "-secondary").rstrip("/")
             if kwargs.get("secondary_hostname"):
                 secondary_hostname = kwargs["secondary_hostname"]
             primary_hostname = (parsed_url.netloc + parsed_url.path).rstrip("/")
@@ -214,12 +204,12 @@ class TablesBaseClient(AccountHostsMixin):
     :ivar str api_version: The service API version.
     """
 
-    def __init__( # pylint: disable=missing-client-constructor-parameter-credential
+    def __init__(  # pylint: disable=missing-client-constructor-parameter-credential
         self,
         endpoint: str,
         *,
         credential: Optional[Union[AzureSasCredential, AzureNamedKeyCredential, TokenCredential]] = None,
-        **kwargs
+        **kwargs,
     ) -> None:
         """Create TablesBaseClient from a Credential.
 
@@ -236,13 +226,9 @@ def __init__( # pylint: disable=missing-client-constructor-parameter-credential
             is "2019-02-02".
         :paramtype api_version: str
         """
-        super(TablesBaseClient, self).__init__(endpoint, credential=credential, **kwargs) # type: ignore
-        self._client = AzureTable(
-            self.url,
-            policies=kwargs.pop('policies', self._policies),
-            **kwargs
-        )
-        self._client._config.version = get_api_version(kwargs, self._client._config.version) # type: ignore # pylint: disable=protected-access
+        super(TablesBaseClient, self).__init__(endpoint, credential=credential, **kwargs)  # type: ignore
+        self._client = AzureTable(self.url, policies=kwargs.pop("policies", self._policies), **kwargs)
+        self._client._config.version = get_api_version(kwargs, self._client._config.version)  # type: ignore # pylint: disable=protected-access
 
     def __enter__(self):
         self._client.__enter__()
@@ -284,17 +270,15 @@ def _batch_send(self, table_name: str, *reqs: HttpRequest, **kwargs) -> List[Map
         policies = [StorageHeadersPolicy()]
 
         changeset = HttpRequest("POST", None)  # type: ignore
-        changeset.set_multipart_mixed(
-            *reqs, policies=policies, boundary=f"changeset_{uuid4()}"  # type: ignore
-        )
+        changeset.set_multipart_mixed(*reqs, policies=policies, boundary=f"changeset_{uuid4()}")  # type: ignore
         request = self._client._client.post(  # pylint: disable=protected-access
             url=f"{self.scheme}://{self._primary_hostname}/$batch",
             headers={
                 "x-ms-version": self.api_version,
                 "DataServiceVersion": "3.0",
                 "MaxDataServiceVersion": "3.0;NetFx",
-                'Content-Type': 'application/json',
-                'Accept': 'application/json'
+                "Content-Type": "application/json",
+                "Accept": "application/json",
             },
         )
         request.set_multipart_mixed(
@@ -307,9 +291,8 @@ def _batch_send(self, table_name: str, *reqs: HttpRequest, **kwargs) -> List[Map
         response = pipeline_response.http_response
         if response.status_code == 413:
             raise _decode_error(
-                response,
-                error_message="The transaction request was too large",
-                error_type=RequestTooLargeError)
+                response, error_message="The transaction request was too large", error_type=RequestTooLargeError
+            )
         if response.status_code != 202:
             decoded = _decode_error(response)
             _validate_tablename_error(decoded, table_name)
@@ -320,13 +303,9 @@ def _batch_send(self, table_name: str, *reqs: HttpRequest, **kwargs) -> List[Map
         if any(error_parts):
             if error_parts[0].status_code == 413:
                 raise _decode_error(
-                    response,
-                    error_message="The transaction request was too large",
-                    error_type=RequestTooLargeError)
-            decoded = _decode_error(
-                response=error_parts[0],
-                error_type=TableTransactionError
-            )
+                    response, error_message="The transaction request was too large", error_type=RequestTooLargeError
+                )
+            decoded = _decode_error(response=error_parts[0], error_type=TableTransactionError)
             _validate_tablename_error(decoded, table_name)
             raise decoded
         return [extract_batch_part_metadata(p) for p in parts]
@@ -346,6 +325,7 @@ class TransportWrapper(HttpTransport):
     :param transport: The Http Transport instance
     :type transport: ~azure.core.pipeline.transport.HttpTransport
     """
+
     def __init__(self, transport):
         self._transport = transport
 
@@ -409,16 +389,17 @@ def parse_connection_str(conn_str, credential, keyword_args):
 
 def extract_batch_part_metadata(response_part):
     metadata = {}
-    if 'Etag' in response_part.headers:
-        metadata['etag'] = response_part.headers['Etag']
+    if "Etag" in response_part.headers:
+        metadata["etag"] = response_part.headers["Etag"]
     return metadata
 
 
 def format_query_string(sas_token, credential):
     query_str = "?"
     if sas_token and isinstance(credential, AzureSasCredential):
         raise ValueError(
-            "You cannot use AzureSasCredential when the resource URI also contains a Shared Access Signature.")
+            "You cannot use AzureSasCredential when the resource URI also contains a Shared Access Signature."
+        )
     if sas_token and not credential:
         query_str += sas_token
     elif credential:
@@ -429,11 +410,7 @@ def format_query_string(sas_token, credential):
 def parse_query(query_str):
     sas_values = QueryStringConstants.to_list()
     parsed_query = {k: v[0] for k, v in parse_qs(query_str).items()}
-    sas_params = [
-        f"{k}={quote(v, safe='')}"
-        for k, v in parsed_query.items()
-        if k in sas_values
-    ]
+    sas_params = [f"{k}={quote(v, safe='')}" for k, v in parsed_query.items() if k in sas_values]
     sas_token = None
     if sas_params:
         sas_token = "&".join(sas_params)

sdk/tables/azure-data-tables/azure/data/tables/_deserialize.py

@@ -22,7 +22,6 @@
 
 
 class TablesEntityDatetime(datetime):
-
     @property
     def tables_service_value(self):
         try:
@@ -60,13 +59,9 @@ def _from_entity_datetime(value):
     # Cosmos returns this with a decimal point that throws an error on deserialization
     cleaned_value = clean_up_dotnet_timestamps(value)
     try:
-        dt_obj = TablesEntityDatetime.strptime(cleaned_value, "%Y-%m-%dT%H:%M:%S.%fZ").replace(
-            tzinfo=timezone.utc
-        )
+        dt_obj = TablesEntityDatetime.strptime(cleaned_value, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=timezone.utc)
     except ValueError:
-        dt_obj = TablesEntityDatetime.strptime(cleaned_value, "%Y-%m-%dT%H:%M:%SZ").replace(
-            tzinfo=timezone.utc
-        )
+        dt_obj = TablesEntityDatetime.strptime(cleaned_value, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
     dt_obj._service_value = value  # pylint:disable=protected-access,assigning-non-slot
     return dt_obj
 
@@ -98,7 +93,7 @@ def _from_entity_guid(value):
 
 def _from_entity_str(value: Union[str, bytes]) -> str:
     if isinstance(value, bytes):
-        return value.decode('utf-8')
+        return value.decode("utf-8")
     return value
 
 
@@ -181,7 +176,7 @@ def _convert_to_entity(entry_element):
         if isinstance(value, int) and mtype is None:
             mtype = EdmType.INT32
 
-            if value >= 2 ** 31 or value < (-(2 ** 31)):
+            if value >= 2**31 or value < (-(2**31)):
                 mtype = EdmType.INT64
 
         # Add type for String
@@ -212,13 +207,13 @@ def _convert_to_entity(entry_element):
         if not etag:
             etag = "W/\"datetime'" + url_quote(timestamp) + "'\""
         timestamp = _from_entity_datetime(timestamp)
-    odata.update({'etag': etag, 'timestamp': timestamp})
+    odata.update({"etag": etag, "timestamp": timestamp})
     entity._metadata = odata  # pylint: disable=protected-access
     return entity
 
 
 def _extract_etag(response):
-    """ Extracts the etag from the response headers.
+    """Extracts the etag from the response headers.
 
     :param response: The PipelineResponse object.
     :type response: ~azure.core.pipeline.PipelineResponse
@@ -255,16 +250,12 @@ def _normalize_headers(headers):
     return normalized
 
 
-def _return_headers_and_deserialized(
-    response, deserialized, response_headers
-):  # pylint: disable=unused-argument
+def _return_headers_and_deserialized(response, deserialized, response_headers):  # pylint: disable=unused-argument
     return _normalize_headers(response_headers), deserialized
 
 
-def _return_context_and_deserialized(
-    response, deserialized, response_headers
-):  # pylint: disable=unused-argument
-    return response.context['location_mode'], deserialized, response_headers
+def _return_context_and_deserialized(response, deserialized, response_headers):  # pylint: disable=unused-argument
+    return response.context["location_mode"], deserialized, response_headers
 
 
 def _trim_service_metadata(metadata: Dict[str, str], content: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
@@ -273,7 +264,7 @@ def _trim_service_metadata(metadata: Dict[str, str], content: Optional[Dict[str,
         "etag": metadata.pop("etag", None),
         "version": metadata.pop("version", None),
     }
-    preference = metadata.pop('preference_applied', None)
+    preference = metadata.pop("preference_applied", None)
     if preference:
         result["preference_applied"] = preference
         result["content"] = content  # type: ignore