corehttp 1.0.0b5__py3-none-any.whl → 1.0.0b6__py3-none-any.whl

corehttp/_version.py

@@ -9,4 +9,4 @@
 # regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "1.0.0b5"
+VERSION = "1.0.0b6"

corehttp/credentials.py

@@ -5,39 +5,71 @@
 # -------------------------------------------------------------------------
 from __future__ import annotations
 from types import TracebackType
-from typing import Any, NamedTuple, Optional, AsyncContextManager, Type
+from typing import NamedTuple, Optional, AsyncContextManager, Type, TypedDict, ContextManager
 from typing_extensions import Protocol, runtime_checkable
 
 
-class AccessToken(NamedTuple):
-    """Represents an OAuth access token."""
+class AccessTokenInfo:
+    """Information about an OAuth access token.
+
+    :param str token: The token string.
+    :param int expires_on: The token's expiration time in Unix time.
+    :keyword str token_type: The type of access token. Defaults to 'Bearer'.
+    :keyword int refresh_on: Specifies the time, in Unix time, when the cached token should be proactively
+        refreshed. Optional.
+    """
 
     token: str
+    """The token string."""
     expires_on: int
+    """The token's expiration time in Unix time."""
+    token_type: str
+    """The type of access token."""
+    refresh_on: Optional[int]
+    """Specifies the time, in Unix time, when the cached token should be proactively refreshed. Optional."""
+
+    def __init__(
+        self, token: str, expires_on: int, *, token_type: str = "Bearer", refresh_on: Optional[int] = None
+    ) -> None:
+        self.token = token
+        self.expires_on = expires_on
+        self.token_type = token_type
+        self.refresh_on = refresh_on
 
+    def __repr__(self) -> str:
+        return "AccessTokenInfo(token='{}', expires_on={}, token_type='{}', refresh_on={})".format(
+            self.token, self.expires_on, self.token_type, self.refresh_on
+        )
 
-AccessToken.token.__doc__ = """The token string."""
-AccessToken.expires_on.__doc__ = """The token's expiration time in Unix time."""
 
+class TokenRequestOptions(TypedDict, total=False):
+    """Options to use for access token requests. All parameters are optional."""
 
-@runtime_checkable
-class TokenCredential(Protocol):
-    """Protocol for classes able to provide OAuth tokens."""
+    claims: str
+    """Additional claims required in the token, such as those returned in a resource provider's claims
+    challenge following an authorization failure."""
+    tenant_id: str
+    """The tenant ID to include in the token request."""
 
-    def get_token(self, *scopes: str, claims: Optional[str] = None, **kwargs: Any) -> AccessToken:
-        """Request an access token for `scopes`.
 
-        :param str scopes: The type of access needed.
+class TokenCredential(Protocol, ContextManager["TokenCredential"]):
+    """Protocol for classes able to provide OAuth access tokens."""
 
-        :keyword str claims: Additional claims required in the token, such as those returned in a resource
-            provider's claims challenge following an authorization failure.
+    def get_token_info(self, *scopes: str, options: Optional[TokenRequestOptions] = None) -> AccessTokenInfo:
+        """Request an access token for `scopes`.
 
+        :param str scopes: The type of access needed.
+        :keyword options: A dictionary of options for the token request. Unknown options will be ignored. Optional.
+        :paramtype options: TokenRequestOptions
 
-        :rtype: AccessToken
-        :return: An AccessToken instance containing the token string and its expiration time in Unix time.
+        :rtype: AccessTokenInfo
+        :return: An AccessTokenInfo instance containing information about the token.
         """
         ...
 
+    def close(self) -> None:
+        pass
+
 
 class ServiceNamedKey(NamedTuple):
     """Represents a name and key pair."""
@@ -47,10 +79,11 @@ class ServiceNamedKey(NamedTuple):
 
 
 __all__ = [
-    "AccessToken",
+    "AccessTokenInfo",
     "ServiceKeyCredential",
     "ServiceNamedKeyCredential",
     "TokenCredential",
+    "TokenRequestOptions",
     "AsyncTokenCredential",
 ]
 
@@ -134,16 +167,15 @@ class ServiceNamedKeyCredential:
 class AsyncTokenCredential(Protocol, AsyncContextManager["AsyncTokenCredential"]):
     """Protocol for classes able to provide OAuth tokens."""
 
-    async def get_token(self, *scopes: str, claims: Optional[str] = None, **kwargs: Any) -> AccessToken:
+    async def get_token_info(self, *scopes: str, options: Optional[TokenRequestOptions] = None) -> AccessTokenInfo:
         """Request an access token for `scopes`.
 
         :param str scopes: The type of access needed.
+        :keyword options: A dictionary of options for the token request. Unknown options will be ignored. Optional.
+        :paramtype options: TokenRequestOptions
 
-        :keyword str claims: Additional claims required in the token, such as those returned in a resource
-            provider's claims challenge following an authorization failure.
-
-        :rtype: AccessToken
-        :return: An AccessToken instance containing the token string and its expiration time in Unix time.
+        :rtype: AccessTokenInfo
+        :return: An AccessTokenInfo instance containing the token string and its expiration time in Unix time.
         """
         ...
 

corehttp/exceptions.py

@@ -72,15 +72,12 @@ class _HttpResponseCommonAPI(Protocol):
     """
 
     @property
-    def reason(self) -> Optional[str]:
-        ...
+    def reason(self) -> Optional[str]: ...
 
     @property
-    def status_code(self) -> Optional[int]:
-        ...
+    def status_code(self) -> Optional[int]: ...
 
-    def text(self) -> str:
-        ...
+    def text(self) -> str: ...
 
     @property
     def request(self) -> object:  # object as type, since all we need is str() on it
@@ -190,6 +187,8 @@ class HttpResponseError(BaseError):
     :vartype status_code: int
     :ivar response: The response that triggered the exception.
     :vartype response: ~corehttp.rest.HttpResponse or ~corehttp.rest.AsyncHttpResponse
+    :ivar model: The response body model
+    :vartype model: Any
     """
 
     def __init__(
@@ -203,6 +202,8 @@ class HttpResponseError(BaseError):
             self.reason = response.reason
             self.status_code = response.status_code
 
+        self.model: Optional[Any] = kwargs.pop("model", None)
+
         # By priority, message is:
         # - parameter "message", OR
         # - generic message using "reason"

corehttp/rest/_aiohttp.py

@@ -30,7 +30,7 @@ import logging
 from itertools import groupby
 from typing import Iterator, cast, TYPE_CHECKING
 from multidict import CIMultiDict
-import aiohttp.client_exceptions  # pylint: disable=all
+import aiohttp.client_exceptions  # pylint: disable=networking-import-outside-azure-core-transport
 
 from ._http_response_impl_async import AsyncHttpResponseImpl
 from ..exceptions import (
@@ -263,7 +263,7 @@ class AioHttpStreamDownloadGenerator(collections.abc.AsyncIterator):
         self.response = response
 
         # TODO: determine if block size should be public on RestAioHttpTransportResponse.
-        self.block_size = response._block_size  # pylint: disable=protected-access
+        self.block_size = response._block_size
         self._decompress = decompress
         self.content_length = int(response.headers.get("Content-Length", 0))
         self._decompressor = None
@@ -272,11 +272,11 @@ class AioHttpStreamDownloadGenerator(collections.abc.AsyncIterator):
         return self.content_length
 
     async def __anext__(self):
-        internal_response = self.response._internal_response  # pylint: disable=protected-access
+        internal_response = self.response._internal_response
         try:
             # TODO: Determine how chunks should be read.
             # chunk = await self.response.internal_response.content.read(self.block_size)
-            chunk = await internal_response.content.read(self.block_size)  # pylint: disable=protected-access
+            chunk = await internal_response.content.read(self.block_size)
             if not chunk:
                 raise _ResponseStopIteration()
             if not self._decompress:

corehttp/rest/_http_response_impl.py

@@ -292,12 +292,7 @@ class HttpResponseImpl(_HttpResponseBaseImpl, _HttpResponse):
                 yield self.content[i : i + chunk_size]
         else:
             self._stream_download_check()
-            for part in self._stream_download_generator(
-                response=self,
-                pipeline=None,
-                decompress=True,
-            ):
-                yield part
+            yield from self._stream_download_generator(response=self, pipeline=None, decompress=True)
         self.close()
 
     def iter_raw(self, **kwargs) -> Iterator[bytes]:
@@ -307,6 +302,5 @@ class HttpResponseImpl(_HttpResponseBaseImpl, _HttpResponse):
         :rtype: Iterator[str]
         """
         self._stream_download_check()
-        for part in self._stream_download_generator(response=self, pipeline=None, decompress=False):
-            yield part
+        yield from self._stream_download_generator(response=self, pipeline=None, decompress=False)
         self.close()

corehttp/rest/_httpx.py

@@ -177,7 +177,7 @@ class AsyncHttpXStreamDownloadGenerator(AsyncIterator):
         return self
 
     async def __anext__(self):
-        internal_response = self.response._internal_response  # pylint: disable=protected-access
+        internal_response = self.response._internal_response
         try:
             return await self.iter_content_func.__anext__()
         except StopAsyncIteration:

corehttp/rest/_requests_basic.py

@@ -27,8 +27,8 @@ from __future__ import annotations
 import logging
 import collections.abc as collections
 from typing import TYPE_CHECKING, Any
-import requests  # pylint: disable=all
-from requests.structures import CaseInsensitiveDict  # pylint: disable=all
+import requests  # pylint: disable=networking-import-outside-azure-core-transport
+from requests.structures import CaseInsensitiveDict  # pylint: disable=networking-import-outside-azure-core-transport
 from urllib3.exceptions import (
     DecodeError as CoreDecodeError,
     ReadTimeoutError,
@@ -122,7 +122,7 @@ class StreamDownloadGenerator:
         self.response = response
 
         # TODO: determine if block size should be public on RestTransportResponse.
-        self.block_size = response._block_size  # pylint: disable=protected-access
+        self.block_size = response._block_size
         decompress = kwargs.pop("decompress", True)
         if len(kwargs) > 0:
             raise TypeError("Got an unexpected keyword argument: {}".format(list(kwargs.keys())[0]))
@@ -172,8 +172,7 @@ def _read_raw_stream(response, chunk_size=1):
     # Special case for urllib3.
     if hasattr(response.raw, "stream"):
         try:
-            for chunk in response.raw.stream(chunk_size, decode_content=False):
-                yield chunk
+            yield from response.raw.stream(chunk_size, decode_content=False)
         except ProtocolError as e:
             raise ServiceResponseError(e, error=e) from e
         except CoreDecodeError as e:

corehttp/rest/_rest_py3.py

@@ -329,16 +329,13 @@ class HttpResponse(_HttpResponseBase):
     """
 
     @abc.abstractmethod
-    def __enter__(self) -> "HttpResponse":
-        ...
+    def __enter__(self) -> "HttpResponse": ...
 
     @abc.abstractmethod
-    def __exit__(self, *args: Any) -> None:
-        ...
+    def __exit__(self, *args: Any) -> None: ...
 
     @abc.abstractmethod
-    def close(self) -> None:
-        ...
+    def close(self) -> None: ...
 
     @abc.abstractmethod
     def read(self) -> bytes:
@@ -415,5 +412,4 @@ class AsyncHttpResponse(_HttpResponseBase, AsyncContextManager["AsyncHttpRespons
         yield  # pylint: disable=unreachable
 
     @abc.abstractmethod
-    async def close(self) -> None:
-        ...
+    async def close(self) -> None: ...

corehttp/runtime/pipeline/__init__.py

@@ -51,9 +51,7 @@ class PipelineContext(Dict[str, Any]):
 
     _PICKLE_CONTEXT = {"deserialized_data"}
 
-    def __init__(
-        self, transport: Optional["TransportType"], **kwargs: Any
-    ) -> None:  # pylint: disable=super-init-not-called
+    def __init__(self, transport: Optional["TransportType"], **kwargs: Any) -> None:
         self.transport: Optional["TransportType"] = transport
         self.options = kwargs
         self._protected = ["transport", "options"]
@@ -113,12 +111,10 @@ class PipelineContext(Dict[str, Any]):
         raise TypeError("Context objects cannot be updated.")
 
     @overload
-    def pop(self, __key: str) -> Any:
-        ...
+    def pop(self, __key: str) -> Any: ...
 
     @overload
-    def pop(self, __key: str, __default: Optional[Any]) -> Any:
-        ...
+    def pop(self, __key: str, __default: Optional[Any]) -> Any: ...
 
     def pop(self, *args: Any) -> Any:
         """Removes specified key and returns the value.

corehttp/runtime/pipeline/_base.py

@@ -153,7 +153,7 @@ class Pipeline(ContextManager["Pipeline"], Generic[HTTPRequestType, HTTPResponse
         self._transport.__enter__()
         return self
 
-    def __exit__(self, *exc_details: Any) -> None:  # pylint: disable=arguments-differ
+    def __exit__(self, *exc_details: Any) -> None:
         self._transport.__exit__(*exc_details)
 
     def run(self, request: HTTPRequestType, **kwargs: Any) -> PipelineResponse[HTTPRequestType, HTTPResponseType]:

corehttp/runtime/pipeline/_base_async.py

@@ -26,8 +26,8 @@
 from __future__ import annotations
 import inspect
 from types import TracebackType
-from typing import Any, Union, Generic, TypeVar, List, Optional, Iterable, Type
-from typing_extensions import AsyncContextManager, TypeGuard
+from typing import Any, Union, Generic, TypeVar, List, Optional, Iterable, Type, AsyncContextManager
+from typing_extensions import TypeGuard
 
 from . import PipelineRequest, PipelineResponse, PipelineContext
 from ..policies import AsyncHTTPPolicy, SansIOHTTPPolicy
@@ -45,9 +45,7 @@ def is_async_http_policy(policy: object) -> TypeGuard[AsyncHTTPPolicy]:
     return False
 
 
-class _SansIOAsyncHTTPPolicyRunner(
-    AsyncHTTPPolicy[HTTPRequestType, AsyncHTTPResponseType]
-):  # pylint: disable=unsubscriptable-object
+class _SansIOAsyncHTTPPolicyRunner(AsyncHTTPPolicy[HTTPRequestType, AsyncHTTPResponseType]):
     """Async implementation of the SansIO policy.
 
     Modifies the request and sends to the next policy in the chain.
@@ -76,9 +74,7 @@ class _SansIOAsyncHTTPPolicyRunner(
         return response
 
 
-class _AsyncTransportRunner(
-    AsyncHTTPPolicy[HTTPRequestType, AsyncHTTPResponseType]
-):  # pylint: disable=unsubscriptable-object
+class _AsyncTransportRunner(AsyncHTTPPolicy[HTTPRequestType, AsyncHTTPResponseType]):
     """Async Transport runner.
 
     Uses specified HTTP transport type to send request and returns response.

corehttp/runtime/pipeline/_tools_async.py

@@ -31,13 +31,11 @@ T = TypeVar("T")
 
 
 @overload
-async def await_result(func: Callable[P, Awaitable[T]], *args: P.args, **kwargs: P.kwargs) -> T:
-    ...
+async def await_result(func: Callable[P, Awaitable[T]], *args: P.args, **kwargs: P.kwargs) -> T: ...
 
 
 @overload
-async def await_result(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
-    ...
+async def await_result(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T: ...
 
 
 async def await_result(func: Callable[P, Union[T, Awaitable[T]]], *args: P.args, **kwargs: P.kwargs) -> T:

corehttp/runtime/policies/_authentication.py

@@ -5,16 +5,17 @@
 # -------------------------------------------------------------------------
 from __future__ import annotations
 import time
-from typing import TYPE_CHECKING, Optional, TypeVar, MutableMapping, Any
+from typing import TYPE_CHECKING, Optional, TypeVar, MutableMapping, Any, Union
 
+from ...credentials import TokenRequestOptions
 from ...rest import HttpResponse, HttpRequest
 from . import HTTPPolicy, SansIOHTTPPolicy
 from ...exceptions import ServiceRequestError
 
 if TYPE_CHECKING:
-    # pylint:disable=unused-import
+
     from ...credentials import (
-        AccessToken,
+        AccessTokenInfo,
         TokenCredential,
         ServiceKeyCredential,
     )
@@ -31,15 +32,23 @@ class _BearerTokenCredentialPolicyBase:
     :param credential: The credential.
     :type credential: ~corehttp.credentials.TokenCredential
     :param str scopes: Lets you specify the type of access needed.
+    :keyword auth_flows: A list of authentication flows to use for the credential.
+    :paramtype auth_flows: list[dict[str, Union[str, list[dict[str, str]]]]]
     """
 
+    # pylint: disable=unused-argument
     def __init__(
-        self, credential: "TokenCredential", *scopes: str, **kwargs: Any  # pylint: disable=unused-argument
+        self,
+        credential: "TokenCredential",
+        *scopes: str,
+        auth_flows: Optional[list[dict[str, Union[str, list[dict[str, str]]]]]] = None,
+        **kwargs: Any,
     ) -> None:
         super(_BearerTokenCredentialPolicyBase, self).__init__()
         self._scopes = scopes
         self._credential = credential
-        self._token: Optional["AccessToken"] = None
+        self._token: Optional["AccessTokenInfo"] = None
+        self._auth_flows = auth_flows
 
     @staticmethod
     def _enforce_https(request: PipelineRequest[HTTPRequestType]) -> None:
@@ -68,7 +77,12 @@ class _BearerTokenCredentialPolicyBase:
 
     @property
     def _need_new_token(self) -> bool:
-        return not self._token or self._token.expires_on - time.time() < 300
+        now = time.time()
+        return (
+            not self._token
+            or (self._token.refresh_on is not None and self._token.refresh_on <= now)
+            or (self._token.expires_on - now < 300)
+        )
 
 
 class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[HTTPRequestType, HTTPResponseType]):
@@ -77,20 +91,30 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
     :param credential: The credential.
     :type credential: ~corehttp.TokenCredential
     :param str scopes: Lets you specify the type of access needed.
+    :keyword auth_flows: A list of authentication flows to use for the credential.
+    :paramtype auth_flows: list[dict[str, Union[str, list[dict[str, str]]]]]
     :raises: :class:`~corehttp.exceptions.ServiceRequestError`
     """
 
-    def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+    def on_request(
+        self,
+        request: PipelineRequest[HTTPRequestType],
+        *,
+        auth_flows: Optional[list[dict[str, Union[str, list[dict[str, str]]]]]] = None,
+    ) -> None:
         """Called before the policy sends a request.
 
         The base implementation authorizes the request with a bearer token.
 
         :param ~corehttp.runtime.pipeline.PipelineRequest request: the request
+        :keyword auth_flows: A list of authentication flows to use for the credential.
+        :paramtype auth_flows: list[dict[str, Union[str, list[dict[str, str]]]]]
         """
         self._enforce_https(request)
 
         if self._token is None or self._need_new_token:
-            self._token = self._credential.get_token(*self._scopes)
+            options: TokenRequestOptions = {"auth_flows": auth_flows} if auth_flows else {}  # type: ignore
+            self._token = self._credential.get_token_info(*self._scopes, options=options)
         self._update_headers(request.http_request.headers, self._token.token)
 
     def authorize_request(self, request: PipelineRequest[HTTPRequestType], *scopes: str, **kwargs: Any) -> None:
@@ -102,7 +126,12 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
         :param ~corehttp.runtime.pipeline.PipelineRequest request: the request
         :param str scopes: required scopes of authentication
         """
-        self._token = self._credential.get_token(*scopes, **kwargs)
+        options: TokenRequestOptions = {}
+        # Loop through all the keyword arguments and check if they are part of the TokenRequestOptions.
+        for key in list(kwargs.keys()):
+            if key in TokenRequestOptions.__annotations__:  # pylint:disable=no-member
+                options[key] = kwargs.pop(key)  # type: ignore[literal-required]
+        self._token = self._credential.get_token_info(*scopes, options=options)
         self._update_headers(request.http_request.headers, self._token.token)
 
     def send(self, request: PipelineRequest[HTTPRequestType]) -> PipelineResponse[HTTPRequestType, HTTPResponseType]:
@@ -113,25 +142,25 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
         :return: The pipeline response object
         :rtype: ~corehttp.runtime.pipeline.PipelineResponse
         """
-        self.on_request(request)
+        self.on_request(request, auth_flows=self._auth_flows)
         try:
             response = self.next.send(request)
-            self.on_response(request, response)
-        except Exception:  # pylint:disable=broad-except
+        except Exception:
             self.on_exception(request)
             raise
-        else:
-            if response.http_response.status_code == 401:
-                self._token = None  # any cached token is invalid
-                if "WWW-Authenticate" in response.http_response.headers:
-                    request_authorized = self.on_challenge(request, response)
-                    if request_authorized:
-                        try:
-                            response = self.next.send(request)
-                            self.on_response(request, response)
-                        except Exception:  # pylint:disable=broad-except
-                            self.on_exception(request)
-                            raise
+
+        self.on_response(request, response)
+        if response.http_response.status_code == 401:
+            self._token = None  # any cached token is invalid
+            if "WWW-Authenticate" in response.http_response.headers:
+                request_authorized = self.on_challenge(request, response)
+                if request_authorized:
+                    try:
+                        response = self.next.send(request)
+                        self.on_response(request, response)
+                    except Exception:
+                        self.on_exception(request)
+                        raise
 
         return response
 

corehttp/runtime/policies/_authentication_async.py

@@ -5,9 +5,9 @@
 # -------------------------------------------------------------------------
 from __future__ import annotations
 import time
-from typing import TYPE_CHECKING, Any, Awaitable, Optional, cast, TypeVar
+from typing import TYPE_CHECKING, Any, Awaitable, Optional, cast, TypeVar, Union
 
-from ...credentials import AccessToken
+from ...credentials import AccessTokenInfo, TokenRequestOptions
 from ..pipeline import PipelineRequest, PipelineResponse
 from ..pipeline._tools_async import await_result
 from ._base_async import AsyncHTTPPolicy
@@ -29,16 +29,24 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
     :param credential: The credential.
     :type credential: ~corehttp.credentials.TokenCredential
     :param str scopes: Lets you specify the type of access needed.
+    :keyword auth_flows: A list of authentication flows to use for the credential.
+    :paramtype auth_flows: list[dict[str, Union[str, list[dict[str, str]]]]]
     """
 
+    # pylint: disable=unused-argument
     def __init__(
-        self, credential: "AsyncTokenCredential", *scopes: str, **kwargs: Any  # pylint: disable=unused-argument
+        self,
+        credential: "AsyncTokenCredential",
+        *scopes: str,
+        auth_flows: Optional[list[dict[str, Union[str, list[dict[str, str]]]]]] = None,
+        **kwargs: Any,
     ) -> None:
         super().__init__()
         self._credential = credential
         self._lock_instance = None
         self._scopes = scopes
-        self._token: Optional["AccessToken"] = None
+        self._token: Optional[AccessTokenInfo] = None
+        self._auth_flows = auth_flows
 
     @property
     def _lock(self):
@@ -46,21 +54,29 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
             self._lock_instance = get_running_async_lock()
         return self._lock_instance
 
-    async def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+    async def on_request(
+        self,
+        request: PipelineRequest[HTTPRequestType],
+        *,
+        auth_flows: Optional[list[dict[str, Union[str, list[dict[str, str]]]]]] = None,
+    ) -> None:
         """Adds a bearer token Authorization header to request and sends request to next policy.
 
         :param request: The pipeline request object to be modified.
         :type request: ~corehttp.runtime.pipeline.PipelineRequest
+        :keyword auth_flows: A list of authentication flows to use for the credential.
+        :paramtype auth_flows: list[dict[str, Union[str, list[dict[str, str]]]]]
         :raises: :class:`~corehttp.exceptions.ServiceRequestError`
         """
         _BearerTokenCredentialPolicyBase._enforce_https(request)  # pylint:disable=protected-access
 
-        if self._token is None or self._need_new_token():
+        if self._token is None or self._need_new_token:
             async with self._lock:
                 # double check because another coroutine may have acquired a token while we waited to acquire the lock
-                if self._token is None or self._need_new_token():
-                    self._token = await await_result(self._credential.get_token, *self._scopes)
-        request.http_request.headers["Authorization"] = "Bearer " + cast(AccessToken, self._token).token
+                if self._token is None or self._need_new_token:
+                    options: TokenRequestOptions = {"auth_flows": auth_flows} if auth_flows else {}  # type: ignore
+                    self._token = await await_result(self._credential.get_token_info, *self._scopes, options=options)
+        request.http_request.headers["Authorization"] = "Bearer " + cast(AccessTokenInfo, self._token).token
 
     async def authorize_request(self, request: PipelineRequest[HTTPRequestType], *scopes: str, **kwargs: Any) -> None:
         """Acquire a token from the credential and authorize the request with it.
@@ -71,9 +87,15 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
         :param ~corehttp.runtime.pipeline.PipelineRequest request: the request
         :param str scopes: required scopes of authentication
         """
+        options: TokenRequestOptions = {}
+        # Loop through all the keyword arguments and check if they are part of the TokenRequestOptions.
+        for key in list(kwargs.keys()):
+            if key in TokenRequestOptions.__annotations__:  # pylint:disable=no-member
+                options[key] = kwargs.pop(key)  # type: ignore[literal-required]
+
         async with self._lock:
-            self._token = await await_result(self._credential.get_token, *scopes, **kwargs)
-        request.http_request.headers["Authorization"] = "Bearer " + cast(AccessToken, self._token).token
+            self._token = await await_result(self._credential.get_token_info, *scopes, options=options)
+        request.http_request.headers["Authorization"] = "Bearer " + cast(AccessTokenInfo, self._token).token
 
     async def send(
         self, request: PipelineRequest[HTTPRequestType]
@@ -85,14 +107,13 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
         :return: The pipeline response object
         :rtype: ~corehttp.runtime.pipeline.PipelineResponse
         """
-        await await_result(self.on_request, request)
+        await await_result(self.on_request, request, auth_flows=self._auth_flows)
         try:
             response = await self.next.send(request)
-        except Exception:  # pylint:disable=broad-except
+        except Exception:
             await await_result(self.on_exception, request)
             raise
-        else:
-            await await_result(self.on_response, request, response)
+        await await_result(self.on_response, request, response)
 
         if response.http_response.status_code == 401:
             self._token = None  # any cached token is invalid
@@ -101,11 +122,10 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
                 if request_authorized:
                     try:
                         response = await self.next.send(request)
-                    except Exception:  # pylint:disable=broad-except
+                    except Exception:
                         await await_result(self.on_exception, request)
                         raise
-                    else:
-                        await await_result(self.on_response, request, response)
+                    await await_result(self.on_response, request, response)
 
         return response
 
@@ -151,5 +171,11 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
         # pylint: disable=unused-argument
         return
 
+    @property
     def _need_new_token(self) -> bool:
-        return not self._token or self._token.expires_on - time.time() < 300
+        now = time.time()
+        return (
+            not self._token
+            or (self._token.refresh_on is not None and self._token.refresh_on <= now)
+            or (self._token.expires_on - now < 300)
+        )

corehttp/runtime/policies/_retry.py

@@ -513,7 +513,7 @@ class RetryPolicy(RetryPolicyBase, HTTPPolicy[HttpRequest, HttpResponse]):
                         is_response_error = True
                         continue
                 break
-            except ClientAuthenticationError:  # pylint:disable=try-except-raise
+            except ClientAuthenticationError:
                 # the authentication policy failed such that the client's request can't
                 # succeed--we'll never have a response to it, so propagate the exception
                 raise

corehttp/runtime/policies/_retry_async.py

@@ -174,7 +174,7 @@ class AsyncRetryPolicy(RetryPolicyBase, AsyncHTTPPolicy[HttpRequest, AsyncHttpRe
                         is_response_error = True
                         continue
                 break
-            except ClientAuthenticationError:  # pylint:disable=try-except-raise
+            except ClientAuthenticationError:
                 # the authentication policy failed such that the client's request can't
                 # succeed--we'll never have a response to it, so propagate the exception
                 raise

corehttp/runtime/policies/_universal.py

@@ -64,9 +64,7 @@ class HeadersPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
     :param dict base_headers: Headers to send with the request.
     """
 
-    def __init__(
-        self, base_headers: Optional[Dict[str, str]] = None, **kwargs: Any
-    ) -> None:  # pylint: disable=super-init-not-called
+    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", {}))
 
@@ -114,9 +112,7 @@ class UserAgentPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
     _USERAGENT = "User-Agent"
     _ENV_ADDITIONAL_USER_AGENT = "CORE_HTTP_USER_AGENT"
 
-    def __init__(
-        self, base_user_agent: Optional[str] = None, **kwargs: Any
-    ) -> None:  # pylint: disable=super-init-not-called
+    def __init__(self, base_user_agent: Optional[str] = None, **kwargs: Any) -> None:
         self.overwrite: bool = kwargs.pop("user_agent_overwrite", False)
         self.use_env: bool = kwargs.pop("user_agent_use_env", True)
         application_id: Optional[str] = kwargs.pop("user_agent", None)
@@ -172,7 +168,6 @@ class UserAgentPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
 
 
 class NetworkTraceLoggingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
-
     """The logging policy in the pipeline is used to output HTTP network trace to the configured logger.
 
     This accepts both global configuration, and per-request level with "enable_http_logger"
@@ -183,9 +178,7 @@ class NetworkTraceLoggingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTy
     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:  # pylint: disable=too-many-return-statements
+    def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
         """Logs HTTP request to the DEBUG logger.
 
         :param request: The PipelineRequest object.
@@ -455,7 +448,7 @@ class ProxyPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
 
     def __init__(
         self, proxies: Optional[MutableMapping[str, str]] = None, **kwargs: Any
-    ):  # pylint: disable=unused-argument,super-init-not-called
+    ):  # pylint: disable=unused-argument
         self.proxies = proxies
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:

corehttp/serialization.py

@@ -114,7 +114,7 @@ def _datetime_as_isostr(dt: Union[datetime, date, time, timedelta]) -> str:
 class CoreJSONEncoder(JSONEncoder):
     """A JSON encoder that's capable of serializing datetime objects and bytes."""
 
-    def default(self, o: Any) -> Any:  # pylint: disable=too-many-return-statements
+    def default(self, o: Any) -> Any:
         if isinstance(o, (bytes, bytearray)):
             return base64.b64encode(o).decode()
         try:

corehttp/transport/aiohttp/_aiohttp.py

@@ -29,8 +29,8 @@ from types import TracebackType
 
 import logging
 import asyncio
-import aiohttp  # pylint: disable=all
-import aiohttp.client_exceptions  # pylint: disable=all
+import aiohttp  # pylint: disable=networking-import-outside-azure-core-transport
+import aiohttp.client_exceptions  # pylint: disable=networking-import-outside-azure-core-transport
 
 from ...exceptions import (
     ServiceRequestError,

corehttp/transport/requests/_bigger_block_size_http_adapters.py

@@ -27,7 +27,7 @@
 import sys
 from typing import MutableMapping, Optional
 
-from requests.adapters import HTTPAdapter  # pylint: disable=all
+from requests.adapters import HTTPAdapter  # pylint: disable=networking-import-outside-azure-core-transport
 from urllib3.connectionpool import ConnectionPool
 
 

corehttp/transport/requests/_requests_basic.py

@@ -31,7 +31,7 @@ from urllib3.exceptions import (
     NewConnectionError,
     ConnectTimeoutError,
 )
-import requests  # pylint: disable=all
+import requests  # pylint: disable=networking-import-outside-azure-core-transport
 
 from ...exceptions import (
     ServiceRequestError,
@@ -89,7 +89,7 @@ class RequestsTransport(HttpTransport):
         self.open()
         return self
 
-    def __exit__(self, *args):  # pylint: disable=arguments-differ
+    def __exit__(self, *args):
         self.close()
 
     def _init_session(self, session: requests.Session) -> None:

corehttp/utils/_enum_meta.py

@@ -45,7 +45,7 @@ class CaseInsensitiveEnumMeta(EnumMeta):
 
     def __getitem__(cls, name: str) -> Any:
         # disabling pylint bc of pylint bug https://github.com/PyCQA/astroid/issues/713
-        return super(CaseInsensitiveEnumMeta, cls).__getitem__(name.upper())  # pylint: disable=no-value-for-parameter
+        return super(CaseInsensitiveEnumMeta, cls).__getitem__(name.upper())
 
     def __getattr__(cls, name: str) -> Enum:
         """Return the enum member matching `name`.

{corehttp-1.0.0b5.dist-info → corehttp-1.0.0b6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: corehttp
-Version: 1.0.0b5
+Version: 1.0.0b6
 Summary: CoreHTTP Library for Python
 Home-page: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/core/corehttp
 Author: Microsoft Corporation
@@ -20,13 +20,13 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: typing-extensions >=4.6.0
+Requires-Dist: typing-extensions>=4.6.0
 Provides-Extra: aiohttp
-Requires-Dist: aiohttp >=3.0 ; extra == 'aiohttp'
+Requires-Dist: aiohttp>=3.0; extra == "aiohttp"
 Provides-Extra: httpx
-Requires-Dist: httpx >=0.25.0 ; extra == 'httpx'
+Requires-Dist: httpx>=0.25.0; extra == "httpx"
 Provides-Extra: requests
-Requires-Dist: requests >=2.18.4 ; extra == 'requests'
+Requires-Dist: requests>=2.18.4; extra == "requests"
 
 
 # Core HTTP shared client library for Python
@@ -87,6 +87,24 @@ additional questions or comments.
 
 # Release History
 
+## 1.0.0b6 (2025-03-27)
+
+### Features Added
+
+- The `TokenCredential` and `AsyncTokenCredential` protocols have been updated to include a new `get_token_info` method. This method should be used to acquire tokens and return an `AccessTokenInfo` object. [#38346](https://github.com/Azure/azure-sdk-for-python/pull/38346)
+- Added a new `TokenRequestOptions` class, which is a `TypedDict` with optional parameters, that can be used to define options for token requests through the `get_token_info` method. [#38346](https://github.com/Azure/azure-sdk-for-python/pull/38346)
+- Added a new `AccessTokenInfo` class, which is returned by `get_token_info` implementations. This class contains the token, its expiration time, and optional additional information like when a token should be refreshed. [#38346](https://github.com/Azure/azure-sdk-for-python/pull/38346)
+- `BearerTokenCredentialPolicy` and `AsyncBearerTokenCredentialPolicy` now check if a credential has the `get_token_info` method defined. If so, the `get_token_info` method is used to acquire a token. [#38346](https://github.com/Azure/azure-sdk-for-python/pull/38346)
+  - These policies now also check the `refresh_on` attribute when determining if a new token request should be made.
+- Added `model` attribute to `HttpResponseError` to allow accessing error attributes based on a known model. [#39636](https://github.com/Azure/azure-sdk-for-python/pull/39636)
+- Added `auth_flows` support in `BearerTokenCredentialPolicy`. [#40084](https://github.com/Azure/azure-sdk-for-python/pull/40084)
+
+### Breaking Changes
+
+- The `get_token` method has been removed from the `TokenCredential` and `AsyncTokenCredential` protocols. Implementations should now use the new `get_token_info` method to acquire tokens. [#38346](https://github.com/Azure/azure-sdk-for-python/pull/38346)
+- The `AccessToken` class has been removed and replaced with a new `AccessTokenInfo` class. [#38346](https://github.com/Azure/azure-sdk-for-python/pull/38346)
+- `BearerTokenCredentialPolicy` and `AsyncBearerTokenCredentialPolicy` now rely on credentials having the `get_token_info` method defined. [#38346](https://github.com/Azure/azure-sdk-for-python/pull/38346)
+
 ## 1.0.0b5 (2024-02-29)
 
 ### Other Changes

{corehttp-1.0.0b5.dist-info → corehttp-1.0.0b6.dist-info}/RECORD

@@ -1,52 +1,52 @@
 corehttp/__init__.py,sha256=Wdidh085sV_IhdV_wU79t7FpghhpyxCsRnZGOUoQ0xs,1443
 corehttp/_match_conditions.py,sha256=3TIhb4vBO1hBe7MaQwS_9i-d6p7o4jn5L6M-OiQahkg,1864
-corehttp/_version.py,sha256=Adx1gY_uaehKHdReRn2zLYGyMjbGV43k9smdJngNeLo,494
-corehttp/credentials.py,sha256=xx94AN5Nekiz3SNHJNV6ncS2o4ObCc5U_Ya62QzTfaM,5237
-corehttp/exceptions.py,sha256=qSqzPJVD_ufGO5HEAbNY8BNmVUoXPCgBeVrw195QvF4,11554
+corehttp/_version.py,sha256=uCj-R1Y_ZRGSi794naubDn0UkPzXOuqPQYRdRChKvBw,494
+corehttp/credentials.py,sha256=EM0k1It1y4_q4cSCRE_m7SjF8npN9aGVBcGhBBfxsmc,6672
+corehttp/exceptions.py,sha256=mKh6wtuYi2aqiZRicNjE_693gBJMkNaWJLuXJ-VE444,11658
 corehttp/paging.py,sha256=zI-fFLBUgMRZmFegD2T6Q52s_3PFDb6lLjtR7-XSZDc,9520
 corehttp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-corehttp/serialization.py,sha256=Q4ZPuh2pHl37T0Lvb96xfXGpMB6oPrmzscLEe0N4Bsw,4090
+corehttp/serialization.py,sha256=HicFY3mGePD0F5F24ryjQ_Igq3XE3vsHOQw0l36w1EI,4044
 corehttp/rest/__init__.py,sha256=GwPFwVYZ9aa4DI9f2-oQGr2nfF7wXvVL80V51ymAjAk,1467
-corehttp/rest/_aiohttp.py,sha256=-_Nym7nY7sy34wNXU_7nA9pngZ24NazuzAheRU2PBJM,11301
+corehttp/rest/_aiohttp.py,sha256=Ld_WrYVOpHodReET9tCJqYfbyNsPDq_uWeDczA1fXUM,11236
 corehttp/rest/_helpers.py,sha256=ZhXhAiAw8DW_gxUPE3tumMplRS1Jt2h6joLVsk-u6yI,7897
-corehttp/rest/_http_response_impl.py,sha256=9I0flIplRZ6-JaWzhcCSTAVnxp_tf6XVCci2nkHCSco,11381
+corehttp/rest/_http_response_impl.py,sha256=qvbvNLyatApp8EMRDxkTHdZMaUoNBp0LJxncUL-uH10,11264
 corehttp/rest/_http_response_impl_async.py,sha256=lmdtY-l0hrNy5PbhWrl2hZrfHzZkn6LZPMR2fTy54WY,4972
-corehttp/rest/_httpx.py,sha256=7mmpEIQ0-GLf3G_Wg3-f2dQnk-mvw4xbqtL9eoPhhwY,8173
-corehttp/rest/_requests_basic.py,sha256=rw2GwxDMMrG5A4onTKLwQpsQe98MtUaowA_-BfTgsuc,7527
-corehttp/rest/_rest_py3.py,sha256=JLLGz6svFF-UwxS_GyGUq5c2KHcNL26TB-ARxfBIOY8,14096
+corehttp/rest/_httpx.py,sha256=5-zpxrd4DyYOx9aNy4H1wHITf0Q38TNTAOhYBoH6liY,8137
+corehttp/rest/_requests_basic.py,sha256=Ihy_y4VMfa4rk-JruYfMYkRmRjX-dgypNL03vm2cQCM,7546
+corehttp/rest/_rest_py3.py,sha256=YFxoRoZgppwve-x0JVv4IZiXuGEwt_1SZyCII5X3Y0c,14064
 corehttp/runtime/__init__.py,sha256=OeG_5-Oq3Zp9rJcMfRNiYLv3V39wIZxDcQ-unerauDw,1469
 corehttp/runtime/_base.py,sha256=gr2xJQJeWuOmtrudFhM07_6ASIhUX66jR1nxSRMh068,5056
 corehttp/runtime/_pipeline_client.py,sha256=A2R0JEcfFIOe6b38VzuQatAxfbiBhtu_RCpOlM968b0,7099
 corehttp/runtime/_pipeline_client_async.py,sha256=dBUqhntQzcS1kbQ6z7d6C4Y3HDghLr4jrobtlKvbVTw,10378
-corehttp/runtime/pipeline/__init__.py,sha256=gRGAsJ1ZDE20TMp6JDw8OpekZdfA7ZzZvOhVHclNpDI,7727
-corehttp/runtime/pipeline/_base.py,sha256=WVLDonxHv5knC-Ffq7YW2cRHr22rtZQjRtZ2N9FWzLw,6900
-corehttp/runtime/pipeline/_base_async.py,sha256=4hvZDFlJ9odUs6Z6etQUlXfm9b1Bt_avZxxEee_h3Sw,7370
+corehttp/runtime/pipeline/__init__.py,sha256=5fxBfA1YQK0gEE2lVmaBdPdlyIk31utG29r959PWxq0,7656
+corehttp/runtime/pipeline/_base.py,sha256=rKJaw4Bv6yq8OzahNuqfSn-ro1pEz7HcbA3DvbFagtw,6864
+corehttp/runtime/pipeline/_base_async.py,sha256=eaFAOMvgvZEM9T8Z7LMWaeLV5EgO6AMgP9ps2A8ZiAs,7274
 corehttp/runtime/pipeline/_tools.py,sha256=iol34Mo_R6-Rezal7WSFFSzFa1V3dXf90AQydnxRnSQ,2004
-corehttp/runtime/pipeline/_tools_async.py,sha256=OvEJjH8NuGnSOrcbJBCIlN_TsO8w87kgEJ0LJcwcYH0,2159
+corehttp/runtime/pipeline/_tools_async.py,sha256=r9Apyo4BOTKSRTfyFjLmcrGiVoulrnpxqkNOmzHOrGg,2151
 corehttp/runtime/policies/__init__.py,sha256=_LPYWjRNkDq45FAHUvyMJ92BL0W6pf7-KrjxSZSkF5c,2196
-corehttp/runtime/policies/_authentication.py,sha256=mgacXdydBBKPQ-5NujqNNWNNCsbt9ETWJBBdqMqgfGc,8819
-corehttp/runtime/policies/_authentication_async.py,sha256=QUUYFlcsc6vJDox7vw1Ggg165c1KXEWiwM70BInoidM,6946
+corehttp/runtime/policies/_authentication.py,sha256=FTu02pWeo3relph_SMvVSDt9xieWTbVypC0bk7WPNPk,10155
+corehttp/runtime/policies/_authentication_async.py,sha256=VabVsVXAjgQhhCtfigMWUIlczS1zi8S6w2m8_e-Irb8,8168
 corehttp/runtime/policies/_base.py,sha256=zLM4NIwGQwZ75k-KPo3PthmDCpDidHvZy91ok0wnFvQ,5063
 corehttp/runtime/policies/_base_async.py,sha256=nOZ-3lrKmfnFam3FbSY4wd9sOI7r5pI2HSdqgOC4Vz4,2531
-corehttp/runtime/policies/_retry.py,sha256=vM40m1JSD-l6yBclxmQV06_ZOK4WAcy1PTqQQpTr3ts,24367
-corehttp/runtime/policies/_retry_async.py,sha256=rsVFxlQMDyU1Z34FKd1trfxj2VkwGt-Ap7uqiErMeAc,9131
-corehttp/runtime/policies/_universal.py,sha256=6qfC2MAQbp1KQgWnbbcBKuwprzEZaftx7tfY6QuHmpo,19835
+corehttp/runtime/policies/_retry.py,sha256=9b7Zts-BemkDRMKxT_P8FkUIr-WZrStN5KbiNLeQU8Q,24332
+corehttp/runtime/policies/_retry_async.py,sha256=eCUqP4IgB7ZMVC9u5DUCDt8JEWikTypLqwUvmF4R-PQ,9096
+corehttp/runtime/policies/_universal.py,sha256=mGXqLgOjKdzuiY62V_ibMaSBiLMKVh9kEAbZ4uxYKqQ,19642
 corehttp/runtime/policies/_utils.py,sha256=kDnGRpC3MxsW7zHZRfkLyPMArlzY4n7vBhwQQVWKQuI,3596
 corehttp/transport/__init__.py,sha256=6A1i9gjM5isBPb-AL-2JTzxn7pssDj8ux9Ujn6rHjlY,1442
 corehttp/transport/_base.py,sha256=5gFTZ1u--3Ik9DyrAe10RtObasd-OXX1y9sRSkbvoyY,5107
 corehttp/transport/_base_async.py,sha256=9zl1Sa8Vm6QBdn8Nf-J3w2qZ-wsjcV9bv1EX5Jr28w4,3827
 corehttp/transport/aiohttp/__init__.py,sha256=gdCazQ9XMZ6xgJCakm4efxECBFU-IIxKuMF3VmM9dHQ,1381
-corehttp/transport/aiohttp/_aiohttp.py,sha256=EesPhF2tAIMxgM0qwFfUu4IUzwF8mHLHbnCD5-Zv8Nk,9565
+corehttp/transport/aiohttp/_aiohttp.py,sha256=HqQWbGhx8kvP4ibqlB3mJEutzpwxAapwnu5EAWwHtiQ,9651
 corehttp/transport/httpx/__init__.py,sha256=IbjUxTxtGljHK9nq6w0kAFeHd73zAl7qtd27qlqCrzg,1412
 corehttp/transport/httpx/_httpx.py,sha256=of8Mxyfzm1Rd4ltYNt8wGz1xuTnJVef0KaiJyl99KfE,8579
 corehttp/transport/requests/__init__.py,sha256=WPdzueqs0eLfvumuedxXPsOIpPCq3dDOvdzmIK4nyHs,1390
-corehttp/transport/requests/_bigger_block_size_http_adapters.py,sha256=0SkJ3lQHdbh1iBlCCbc9NCshDRJsVLZUZdWL-frZ_4Q,2444
-corehttp/transport/requests/_requests_basic.py,sha256=ChsXobJeBdwLTnNnDzWLZi5JYVg6M95kcxXfcgPZ3r0,8179
+corehttp/transport/requests/_bigger_block_size_http_adapters.py,sha256=S1zE3v6QwPtdEm2cLdu8B5iW5WbETTgpv0datZ9g_eo,2487
+corehttp/transport/requests/_requests_basic.py,sha256=dU8gup_4IytJIyfYtMMBb8sIMP2LsNJYjGxjnBwzP3o,8186
 corehttp/utils/__init__.py,sha256=_h2vJje1Tb-w_9mXm0hO_s2S1b48HLzI4taIlvz3Eu4,1648
-corehttp/utils/_enum_meta.py,sha256=l2K1mZfpwljsruKxknabYckl0ZbsVftOxfbRhpzF_-s,2816
+corehttp/utils/_enum_meta.py,sha256=9rdoxCOiBnYFMUC8-8_yaoCA9s_GdbIkguxk3Z71iyM,2774
 corehttp/utils/_utils.py,sha256=TN2IplPve8b6xJPMvIVE-2oF3u_SK89XtYmCb70UDr4,6063
-corehttp-1.0.0b5.dist-info/LICENSE,sha256=_VMkgdgo4ToLE8y1mOAjOKNhd0BnWoYu5r3BVBto6T0,1073
-corehttp-1.0.0b5.dist-info/METADATA,sha256=aTKL6zrEYPPerCUAbEj_uhl07Ex2CsbndYBd3nwjShA,5363
-corehttp-1.0.0b5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-corehttp-1.0.0b5.dist-info/top_level.txt,sha256=NAGJ-rIA_vW2ZJghxC5NqIbnfrXDBMmE-TAd-9ud4i4,9
-corehttp-1.0.0b5.dist-info/RECORD,,
+corehttp-1.0.0b6.dist-info/LICENSE,sha256=_VMkgdgo4ToLE8y1mOAjOKNhd0BnWoYu5r3BVBto6T0,1073
+corehttp-1.0.0b6.dist-info/METADATA,sha256=2gL4eNLJqe2RZthG1GvAQ0zHKZZn7nqrDFshWc8UdmQ,7548
+corehttp-1.0.0b6.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+corehttp-1.0.0b6.dist-info/top_level.txt,sha256=NAGJ-rIA_vW2ZJghxC5NqIbnfrXDBMmE-TAd-9ud4i4,9
+corehttp-1.0.0b6.dist-info/RECORD,,

{corehttp-1.0.0b5.dist-info → corehttp-1.0.0b6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (75.3.2)
 Root-Is-Purelib: true
 Tag: py3-none-any