databricks-sdk 0.44.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

databricks/sdk/__init__.py

@@ -122,6 +122,7 @@ def _make_dbutils(config: client.Config):
 
     # We are in runtime, so we can use the runtime dbutils
     from databricks.sdk.runtime import dbutils as runtime_dbutils
+
     return runtime_dbutils
 
 
@@ -138,58 +139,62 @@ class WorkspaceClient:
     The WorkspaceClient is a client for the workspace-level Databricks REST API.
     """
 
-    def __init__(self,
-                 *,
-                 host: Optional[str] = None,
-                 account_id: Optional[str] = None,
-                 username: Optional[str] = None,
-                 password: Optional[str] = None,
-                 client_id: Optional[str] = None,
-                 client_secret: Optional[str] = None,
-                 token: Optional[str] = None,
-                 profile: Optional[str] = None,
-                 config_file: Optional[str] = None,
-                 azure_workspace_resource_id: Optional[str] = None,
-                 azure_client_secret: Optional[str] = None,
-                 azure_client_id: Optional[str] = None,
-                 azure_tenant_id: Optional[str] = None,
-                 azure_environment: Optional[str] = None,
-                 auth_type: Optional[str] = None,
-                 cluster_id: Optional[str] = None,
-                 google_credentials: Optional[str] = None,
-                 google_service_account: Optional[str] = None,
-                 debug_truncate_bytes: Optional[int] = None,
-                 debug_headers: Optional[bool] = None,
-                 product="unknown",
-                 product_version="0.0.0",
-                 credentials_strategy: Optional[CredentialsStrategy] = None,
-                 credentials_provider: Optional[CredentialsStrategy] = None,
-                 config: Optional[client.Config] = None):
+    def __init__(
+        self,
+        *,
+        host: Optional[str] = None,
+        account_id: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        token: Optional[str] = None,
+        profile: Optional[str] = None,
+        config_file: Optional[str] = None,
+        azure_workspace_resource_id: Optional[str] = None,
+        azure_client_secret: Optional[str] = None,
+        azure_client_id: Optional[str] = None,
+        azure_tenant_id: Optional[str] = None,
+        azure_environment: Optional[str] = None,
+        auth_type: Optional[str] = None,
+        cluster_id: Optional[str] = None,
+        google_credentials: Optional[str] = None,
+        google_service_account: Optional[str] = None,
+        debug_truncate_bytes: Optional[int] = None,
+        debug_headers: Optional[bool] = None,
+        product="unknown",
+        product_version="0.0.0",
+        credentials_strategy: Optional[CredentialsStrategy] = None,
+        credentials_provider: Optional[CredentialsStrategy] = None,
+        config: Optional[client.Config] = None,
+    ):
         if not config:
-            config = client.Config(host=host,
-                                   account_id=account_id,
-                                   username=username,
-                                   password=password,
-                                   client_id=client_id,
-                                   client_secret=client_secret,
-                                   token=token,
-                                   profile=profile,
-                                   config_file=config_file,
-                                   azure_workspace_resource_id=azure_workspace_resource_id,
-                                   azure_client_secret=azure_client_secret,
-                                   azure_client_id=azure_client_id,
-                                   azure_tenant_id=azure_tenant_id,
-                                   azure_environment=azure_environment,
-                                   auth_type=auth_type,
-                                   cluster_id=cluster_id,
-                                   google_credentials=google_credentials,
-                                   google_service_account=google_service_account,
-                                   credentials_strategy=credentials_strategy,
-                                   credentials_provider=credentials_provider,
-                                   debug_truncate_bytes=debug_truncate_bytes,
-                                   debug_headers=debug_headers,
-                                   product=product,
-                                   product_version=product_version)
+            config = client.Config(
+                host=host,
+                account_id=account_id,
+                username=username,
+                password=password,
+                client_id=client_id,
+                client_secret=client_secret,
+                token=token,
+                profile=profile,
+                config_file=config_file,
+                azure_workspace_resource_id=azure_workspace_resource_id,
+                azure_client_secret=azure_client_secret,
+                azure_client_id=azure_client_id,
+                azure_tenant_id=azure_tenant_id,
+                azure_environment=azure_environment,
+                auth_type=auth_type,
+                cluster_id=cluster_id,
+                google_credentials=google_credentials,
+                google_service_account=google_service_account,
+                credentials_strategy=credentials_strategy,
+                credentials_provider=credentials_provider,
+                debug_truncate_bytes=debug_truncate_bytes,
+                debug_headers=debug_headers,
+                product=product,
+                product_version=product_version,
+            )
         self._config = config.copy()
         self._dbutils = _make_dbutils(self._config)
         self._api_client = client.ApiClient(self._config)
@@ -212,7 +217,8 @@ class WorkspaceClient:
         self._consumer_installations = service.marketplace.ConsumerInstallationsAPI(self._api_client)
         self._consumer_listings = service.marketplace.ConsumerListingsAPI(self._api_client)
         self._consumer_personalization_requests = service.marketplace.ConsumerPersonalizationRequestsAPI(
-            self._api_client)
+            self._api_client
+        )
         self._consumer_providers = service.marketplace.ConsumerProvidersAPI(self._api_client)
         self._credentials = service.catalog.CredentialsAPI(self._api_client)
         self._credentials_manager = service.settings.CredentialsManagerAPI(self._api_client)
@@ -246,8 +252,7 @@ class WorkspaceClient:
         self._permission_migration = service.iam.PermissionMigrationAPI(self._api_client)
         self._permissions = service.iam.PermissionsAPI(self._api_client)
         self._pipelines = service.pipelines.PipelinesAPI(self._api_client)
-        self._policy_compliance_for_clusters = service.compute.PolicyComplianceForClustersAPI(
-            self._api_client)
+        self._policy_compliance_for_clusters = service.compute.PolicyComplianceForClustersAPI(self._api_client)
         self._policy_compliance_for_jobs = service.jobs.PolicyComplianceForJobsAPI(self._api_client)
         self._policy_families = service.compute.PolicyFamiliesAPI(self._api_client)
         self._provider_exchange_filters = service.marketplace.ProviderExchangeFiltersAPI(self._api_client)
@@ -255,9 +260,11 @@ class WorkspaceClient:
         self._provider_files = service.marketplace.ProviderFilesAPI(self._api_client)
         self._provider_listings = service.marketplace.ProviderListingsAPI(self._api_client)
         self._provider_personalization_requests = service.marketplace.ProviderPersonalizationRequestsAPI(
-            self._api_client)
+            self._api_client
+        )
         self._provider_provider_analytics_dashboards = service.marketplace.ProviderProviderAnalyticsDashboardsAPI(
-            self._api_client)
+            self._api_client
+        )
         self._provider_providers = service.marketplace.ProviderProvidersAPI(self._api_client)
         self._providers = service.sharing.ProvidersAPI(self._api_client)
         self._quality_monitors = service.catalog.QualityMonitorsAPI(self._api_client)
@@ -278,7 +285,8 @@ class WorkspaceClient:
         self._service_principals = service.iam.ServicePrincipalsAPI(self._api_client)
         self._serving_endpoints = serving_endpoints
         self._serving_endpoints_data_plane = service.serving.ServingEndpointsDataPlaneAPI(
-            self._api_client, serving_endpoints)
+            self._api_client, serving_endpoints
+        )
         self._settings = service.settings.SettingsAPI(self._api_client)
         self._shares = service.sharing.SharesAPI(self._api_client)
         self._statement_execution = service.sql.StatementExecutionAPI(self._api_client)
@@ -606,8 +614,7 @@ class WorkspaceClient:
         return self._provider_personalization_requests
 
     @property
-    def provider_provider_analytics_dashboards(
-            self) -> service.marketplace.ProviderProviderAnalyticsDashboardsAPI:
+    def provider_provider_analytics_dashboards(self) -> service.marketplace.ProviderProviderAnalyticsDashboardsAPI:
         """Manage templated analytics solution for providers."""
         return self._provider_provider_analytics_dashboards
 
@@ -803,9 +810,7 @@ class WorkspaceClient:
 
     def get_workspace_id(self) -> int:
         """Get the workspace ID of the workspace that this client is connected to."""
-        response = self._api_client.do("GET",
-                                       "/api/2.0/preview/scim/v2/Me",
-                                       response_headers=['X-Databricks-Org-Id'])
+        response = self._api_client.do("GET", "/api/2.0/preview/scim/v2/Me", response_headers=["X-Databricks-Org-Id"])
         return int(response["X-Databricks-Org-Id"])
 
     def __repr__(self):
@@ -817,58 +822,62 @@ class AccountClient:
     The AccountClient is a client for the account-level Databricks REST API.
     """
 
-    def __init__(self,
-                 *,
-                 host: Optional[str] = None,
-                 account_id: Optional[str] = None,
-                 username: Optional[str] = None,
-                 password: Optional[str] = None,
-                 client_id: Optional[str] = None,
-                 client_secret: Optional[str] = None,
-                 token: Optional[str] = None,
-                 profile: Optional[str] = None,
-                 config_file: Optional[str] = None,
-                 azure_workspace_resource_id: Optional[str] = None,
-                 azure_client_secret: Optional[str] = None,
-                 azure_client_id: Optional[str] = None,
-                 azure_tenant_id: Optional[str] = None,
-                 azure_environment: Optional[str] = None,
-                 auth_type: Optional[str] = None,
-                 cluster_id: Optional[str] = None,
-                 google_credentials: Optional[str] = None,
-                 google_service_account: Optional[str] = None,
-                 debug_truncate_bytes: Optional[int] = None,
-                 debug_headers: Optional[bool] = None,
-                 product="unknown",
-                 product_version="0.0.0",
-                 credentials_strategy: Optional[CredentialsStrategy] = None,
-                 credentials_provider: Optional[CredentialsStrategy] = None,
-                 config: Optional[client.Config] = None):
+    def __init__(
+        self,
+        *,
+        host: Optional[str] = None,
+        account_id: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        token: Optional[str] = None,
+        profile: Optional[str] = None,
+        config_file: Optional[str] = None,
+        azure_workspace_resource_id: Optional[str] = None,
+        azure_client_secret: Optional[str] = None,
+        azure_client_id: Optional[str] = None,
+        azure_tenant_id: Optional[str] = None,
+        azure_environment: Optional[str] = None,
+        auth_type: Optional[str] = None,
+        cluster_id: Optional[str] = None,
+        google_credentials: Optional[str] = None,
+        google_service_account: Optional[str] = None,
+        debug_truncate_bytes: Optional[int] = None,
+        debug_headers: Optional[bool] = None,
+        product="unknown",
+        product_version="0.0.0",
+        credentials_strategy: Optional[CredentialsStrategy] = None,
+        credentials_provider: Optional[CredentialsStrategy] = None,
+        config: Optional[client.Config] = None,
+    ):
         if not config:
-            config = client.Config(host=host,
-                                   account_id=account_id,
-                                   username=username,
-                                   password=password,
-                                   client_id=client_id,
-                                   client_secret=client_secret,
-                                   token=token,
-                                   profile=profile,
-                                   config_file=config_file,
-                                   azure_workspace_resource_id=azure_workspace_resource_id,
-                                   azure_client_secret=azure_client_secret,
-                                   azure_client_id=azure_client_id,
-                                   azure_tenant_id=azure_tenant_id,
-                                   azure_environment=azure_environment,
-                                   auth_type=auth_type,
-                                   cluster_id=cluster_id,
-                                   google_credentials=google_credentials,
-                                   google_service_account=google_service_account,
-                                   credentials_strategy=credentials_strategy,
-                                   credentials_provider=credentials_provider,
-                                   debug_truncate_bytes=debug_truncate_bytes,
-                                   debug_headers=debug_headers,
-                                   product=product,
-                                   product_version=product_version)
+            config = client.Config(
+                host=host,
+                account_id=account_id,
+                username=username,
+                password=password,
+                client_id=client_id,
+                client_secret=client_secret,
+                token=token,
+                profile=profile,
+                config_file=config_file,
+                azure_workspace_resource_id=azure_workspace_resource_id,
+                azure_client_secret=azure_client_secret,
+                azure_client_id=azure_client_id,
+                azure_tenant_id=azure_tenant_id,
+                azure_environment=azure_environment,
+                auth_type=auth_type,
+                cluster_id=cluster_id,
+                google_credentials=google_credentials,
+                google_service_account=google_service_account,
+                credentials_strategy=credentials_strategy,
+                credentials_provider=credentials_provider,
+                debug_truncate_bytes=debug_truncate_bytes,
+                debug_headers=debug_headers,
+                product=product,
+                product_version=product_version,
+            )
         self._config = config.copy()
         self._api_client = client.ApiClient(self._config)
         self._access_control = service.iam.AccountAccessControlAPI(self._api_client)
@@ -888,8 +897,7 @@ class AccountClient:
         self._o_auth_published_apps = service.oauth2.OAuthPublishedAppsAPI(self._api_client)
         self._private_access = service.provisioning.PrivateAccessAPI(self._api_client)
         self._published_app_integration = service.oauth2.PublishedAppIntegrationAPI(self._api_client)
-        self._service_principal_federation_policy = service.oauth2.ServicePrincipalFederationPolicyAPI(
-            self._api_client)
+        self._service_principal_federation_policy = service.oauth2.ServicePrincipalFederationPolicyAPI(self._api_client)
         self._service_principal_secrets = service.oauth2.ServicePrincipalSecretsAPI(self._api_client)
         self._service_principals = service.iam.AccountServicePrincipalsAPI(self._api_client)
         self._settings = service.settings.AccountSettingsAPI(self._api_client)

databricks/sdk/_base_client.py

@@ -17,7 +17,7 @@ from .errors import DatabricksError, _ErrorCustomizer, _Parser
 from .logger import RoundTrip
 from .retries import retried
 
-logger = logging.getLogger('databricks.sdk')
+logger = logging.getLogger("databricks.sdk")
 
 
 def _fix_host_if_needed(host: Optional[str]) -> Optional[str]:
@@ -25,35 +25,37 @@ def _fix_host_if_needed(host: Optional[str]) -> Optional[str]:
         return host
 
     # Add a default scheme if it's missing
-    if '://' not in host:
-        host = 'https://' + host
+    if "://" not in host:
+        host = "https://" + host
 
     o = urllib.parse.urlparse(host)
     # remove trailing slash
-    path = o.path.rstrip('/')
+    path = o.path.rstrip("/")
     # remove port if 443
     netloc = o.netloc
     if o.port == 443:
-        netloc = netloc.split(':')[0]
+        netloc = netloc.split(":")[0]
 
     return urllib.parse.urlunparse((o.scheme, netloc, path, o.params, o.query, o.fragment))
 
 
 class _BaseClient:
 
-    def __init__(self,
-                 debug_truncate_bytes: int = None,
-                 retry_timeout_seconds: int = None,
-                 user_agent_base: str = None,
-                 header_factory: Callable[[], dict] = None,
-                 max_connection_pools: int = None,
-                 max_connections_per_pool: int = None,
-                 pool_block: bool = True,
-                 http_timeout_seconds: float = None,
-                 extra_error_customizers: List[_ErrorCustomizer] = None,
-                 debug_headers: bool = False,
-                 clock: Clock = None,
-                 streaming_buffer_size: int = 1024 * 1024): # 1MB
+    def __init__(
+        self,
+        debug_truncate_bytes: Optional[int] = None,
+        retry_timeout_seconds: Optional[int] = None,
+        user_agent_base: Optional[str] = None,
+        header_factory: Optional[Callable[[], dict]] = None,
+        max_connection_pools: Optional[int] = None,
+        max_connections_per_pool: Optional[int] = None,
+        pool_block: Optional[bool] = True,
+        http_timeout_seconds: Optional[float] = None,
+        extra_error_customizers: Optional[List[_ErrorCustomizer]] = None,
+        debug_headers: Optional[bool] = False,
+        clock: Optional[Clock] = None,
+        streaming_buffer_size: int = 1024 * 1024,
+    ):  # 1MB
         """
         :param debug_truncate_bytes:
         :param retry_timeout_seconds:
@@ -87,9 +89,11 @@ class _BaseClient:
         # We don't use `max_retries` from HTTPAdapter to align with a more production-ready
         # retry strategy established in the Databricks SDK for Go. See _is_retryable and
         # @retried for more details.
-        http_adapter = requests.adapters.HTTPAdapter(pool_connections=max_connections_per_pool or 20,
-                                                     pool_maxsize=max_connection_pools or 20,
-                                                     pool_block=pool_block)
+        http_adapter = requests.adapters.HTTPAdapter(
+            pool_connections=max_connections_per_pool or 20,
+            pool_maxsize=max_connection_pools or 20,
+            pool_block=pool_block,
+        )
         self._session.mount("https://", http_adapter)
 
         # Default to 60 seconds
@@ -110,7 +114,7 @@ class _BaseClient:
         # See: https://github.com/databricks/databricks-sdk-py/issues/142
         if query is None:
             return None
-        with_fixed_bools = {k: v if type(v) != bool else ('true' if v else 'false') for k, v in query.items()}
+        with_fixed_bools = {k: v if type(v) != bool else ("true" if v else "false") for k, v in query.items()}
 
         # Query parameters may be nested, e.g.
         # {'filter_by': {'user_ids': [123, 456]}}
@@ -140,30 +144,34 @@ class _BaseClient:
             return False
         return data.seekable()
 
-    def do(self,
-           method: str,
-           url: str,
-           query: dict = None,
-           headers: dict = None,
-           body: dict = None,
-           raw: bool = False,
-           files=None,
-           data=None,
-           auth: Callable[[requests.PreparedRequest], requests.PreparedRequest] = None,
-           response_headers: List[str] = None) -> Union[dict, list, BinaryIO]:
+    def do(
+        self,
+        method: str,
+        url: str,
+        query: Optional[dict] = None,
+        headers: Optional[dict] = None,
+        body: Optional[dict] = None,
+        raw: bool = False,
+        files=None,
+        data=None,
+        auth: Optional[Callable[[requests.PreparedRequest], requests.PreparedRequest]] = None,
+        response_headers: Optional[List[str]] = None,
+    ) -> Union[dict, list, BinaryIO]:
         if headers is None:
             headers = {}
-        headers['User-Agent'] = self._user_agent_base
+        headers["User-Agent"] = self._user_agent_base
 
         # Wrap strings and bytes in a seekable stream so that we can rewind them.
         if isinstance(data, (str, bytes)):
-            data = io.BytesIO(data.encode('utf-8') if isinstance(data, str) else data)
+            data = io.BytesIO(data.encode("utf-8") if isinstance(data, str) else data)
 
         if not data:
             # The request is not a stream.
-            call = retried(timeout=timedelta(seconds=self._retry_timeout_seconds),
-                           is_retryable=self._is_retryable,
-                           clock=self._clock)(self._perform)
+            call = retried(
+                timeout=timedelta(seconds=self._retry_timeout_seconds),
+                is_retryable=self._is_retryable,
+                clock=self._clock,
+            )(self._perform)
         elif self._is_seekable_stream(data):
             # Keep track of the initial position of the stream so that we can rewind to it
             # if we need to retry the request.
@@ -173,25 +181,29 @@ class _BaseClient:
                 logger.debug(f"Rewinding input data to offset {initial_data_position} before retry")
                 data.seek(initial_data_position)
 
-            call = retried(timeout=timedelta(seconds=self._retry_timeout_seconds),
-                           is_retryable=self._is_retryable,
-                           clock=self._clock,
-                           before_retry=rewind)(self._perform)
+            call = retried(
+                timeout=timedelta(seconds=self._retry_timeout_seconds),
+                is_retryable=self._is_retryable,
+                clock=self._clock,
+                before_retry=rewind,
+            )(self._perform)
         else:
             # Do not retry if the stream is not seekable. This is necessary to avoid bugs
             # where the retry doesn't re-read already read data from the stream.
             logger.debug(f"Retry disabled for non-seekable stream: type={type(data)}")
             call = self._perform
 
-        response = call(method,
-                        url,
-                        query=query,
-                        headers=headers,
-                        body=body,
-                        raw=raw,
-                        files=files,
-                        data=data,
-                        auth=auth)
+        response = call(
+            method,
+            url,
+            query=query,
+            headers=headers,
+            body=body,
+            raw=raw,
+            files=files,
+            data=data,
+            auth=auth,
+        )
 
         resp = dict()
         for header in response_headers if response_headers else []:
@@ -220,6 +232,7 @@ class _BaseClient:
         # and Databricks SDK for Go retries
         # (see https://github.com/databricks/databricks-sdk-go/blob/main/apierr/errors.go)
         from urllib3.exceptions import ProxyError
+
         if isinstance(err, ProxyError):
             err = err.original_error
         if isinstance(err, requests.ConnectionError):
@@ -230,48 +243,55 @@ class _BaseClient:
             #
             # return a simple string for debug log readability, as `raise TimeoutError(...) from err`
             # will bubble up the original exception in case we reach max retries.
-            return f'cannot connect'
+            return f"cannot connect"
         if isinstance(err, requests.Timeout):
             # corresponds to `TLS handshake timeout` and `i/o timeout` in Go.
             #
             # return a simple string for debug log readability, as `raise TimeoutError(...) from err`
             # will bubble up the original exception in case we reach max retries.
-            return f'timeout'
+            return f"timeout"
         if isinstance(err, DatabricksError):
             message = str(err)
             transient_error_string_matches = [
                 "com.databricks.backend.manager.util.UnknownWorkerEnvironmentException",
-                "does not have any associated worker environments", "There is no worker environment with id",
-                "Unknown worker environment", "ClusterNotReadyException", "Unexpected error",
+                "does not have any associated worker environments",
+                "There is no worker environment with id",
+                "Unknown worker environment",
+                "ClusterNotReadyException",
+                "Unexpected error",
                 "Please try again later or try a faster operation.",
                 "RPC token bucket limit has been exceeded",
             ]
             for substring in transient_error_string_matches:
                 if substring not in message:
                     continue
-                return f'matched {substring}'
+                return f"matched {substring}"
         return None
 
-    def _perform(self,
-                 method: str,
-                 url: str,
-                 query: dict = None,
-                 headers: dict = None,
-                 body: dict = None,
-                 raw: bool = False,
-                 files=None,
-                 data=None,
-                 auth: Callable[[requests.PreparedRequest], requests.PreparedRequest] = None):
-        response = self._session.request(method,
-                                         url,
-                                         params=self._fix_query_string(query),
-                                         json=body,
-                                         headers=headers,
-                                         files=files,
-                                         data=data,
-                                         auth=auth,
-                                         stream=raw,
-                                         timeout=self._http_timeout_seconds)
+    def _perform(
+        self,
+        method: str,
+        url: str,
+        query: Optional[dict] = None,
+        headers: Optional[dict] = None,
+        body: Optional[dict] = None,
+        raw: bool = False,
+        files=None,
+        data=None,
+        auth: Callable[[requests.PreparedRequest], requests.PreparedRequest] = None,
+    ):
+        response = self._session.request(
+            method,
+            url,
+            params=self._fix_query_string(query),
+            json=body,
+            headers=headers,
+            files=files,
+            data=data,
+            auth=auth,
+            stream=raw,
+            timeout=self._http_timeout_seconds,
+        )
         self._record_request_log(response, raw=raw or data is not None or files is not None)
         error = self._error_parser.get_api_error(response)
         if error is not None:
@@ -305,14 +325,14 @@ class _StreamingResponse(BinaryIO):
     _closed: bool = False
 
     def fileno(self) -> int:
-        pass
+        return 0
 
-    def flush(self) -> int:
-        pass
+    def flush(self) -> int:  # type: ignore
+        return 0
 
     def __init__(self, response: _RawResponse, chunk_size: Union[int, None] = None):
         self._response = response
-        self._buffer = b''
+        self._buffer = b""
         self._content = None
         self._chunk_size = chunk_size
 
@@ -338,14 +358,14 @@ class _StreamingResponse(BinaryIO):
 
     def read(self, n: int = -1) -> bytes:
         """
-        Read up to n bytes from the response stream. If n is negative, read 
-        until the end of the stream. 
+        Read up to n bytes from the response stream. If n is negative, read
+        until the end of the stream.
         """
 
         self._open()
         read_everything = n < 0
         remaining_bytes = n
-        res = b''
+        res = b""
         while remaining_bytes > 0 or read_everything:
             if len(self._buffer) == 0:
                 try:
@@ -383,10 +403,10 @@ class _StreamingResponse(BinaryIO):
     def writable(self) -> bool:
         return False
 
-    def write(self, s: Union[bytes, bytearray]) -> int:
+    def write(self, s: Union[bytes, bytearray]) -> int:  # type: ignore
         raise NotImplementedError()
 
-    def writelines(self, lines: Iterable[bytes]) -> None:
+    def writelines(self, lines: Iterable[bytes]) -> None:  # type: ignore
         raise NotImplementedError()
 
     def __next__(self) -> bytes:
@@ -395,8 +415,12 @@ class _StreamingResponse(BinaryIO):
     def __iter__(self) -> Iterator[bytes]:
         return self._content
 
-    def __exit__(self, t: Union[Type[BaseException], None], value: Union[BaseException, None],
-                 traceback: Union[TracebackType, None]) -> None:
+    def __exit__(
+        self,
+        t: Union[Type[BaseException], None],
+        value: Union[BaseException, None],
+        traceback: Union[TracebackType, None],
+    ) -> None:
         self._content = None
-        self._buffer = b''
+        self._buffer = b""
         self.close()