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

corehttp/settings.py

@@ -0,0 +1,59 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+import os
+from typing import Union
+
+
+def _convert_bool(value: Union[str, bool]) -> bool:
+    """Convert a string to True or False
+
+    If a boolean is passed in, it is returned as-is. Otherwise the function
+    maps the following strings, ignoring case:
+
+    * "yes", "1", "on" -> True
+    * "no", "0", "off" -> False
+
+    :param value: the value to convert
+    :type value: str or bool
+    :returns: A boolean value matching the intent of the input
+    :rtype: bool
+    :raises ValueError: If conversion to bool fails
+
+    """
+    if isinstance(value, bool):
+        return value
+    val = value.lower()
+    if val in ["yes", "1", "on", "true", "True"]:
+        return True
+    if val in ["no", "0", "off", "false", "False"]:
+        return False
+    raise ValueError("Cannot convert {} to boolean value".format(value))
+
+
+class Settings:
+    """Global settings for the SDK."""
+
+    def __init__(self) -> None:
+        self._tracing_enabled: bool = _convert_bool(os.environ.get("SDK_TRACING_ENABLED", False))
+
+    @property
+    def tracing_enabled(self) -> bool:
+        """Whether tracing for SDKs is enabled.
+
+        :return: True if tracing is enabled, False otherwise.
+        :rtype: bool
+        """
+        return self._tracing_enabled
+
+    @tracing_enabled.setter
+    def tracing_enabled(self, value: bool):
+        self._tracing_enabled = _convert_bool(value)
+
+
+settings: Settings = Settings()
+"""The settings global instance.
+
+:type settings: Settings
+"""

corehttp/transport/_base.py

@@ -80,10 +80,8 @@ def _handle_non_stream_rest_response(response: HttpResponse) -> None:
     """
     try:
         response.read()
+    finally:
         response.close()
-    except Exception as exc:
-        response.close()
-        raise exc
 
 
 class HttpTransport(ContextManager["HttpTransport"], abc.ABC, Generic[HTTPRequestType, HTTPResponseType]):

corehttp/transport/_base_async.py

@@ -46,10 +46,8 @@ async def _handle_non_stream_rest_response(response: AsyncHttpResponse) -> None:
     """
     try:
         await response.read()
+    finally:
         await response.close()
-    except Exception as exc:
-        await response.close()
-        raise exc
 
 
 class _ResponseStopIteration(Exception):

corehttp/transport/aiohttp/_aiohttp.py

@@ -24,17 +24,19 @@
 #
 # --------------------------------------------------------------------------
 from __future__ import annotations
-from typing import Optional, TYPE_CHECKING, Type, cast, MutableMapping
+from typing import Optional, TYPE_CHECKING, Type, MutableMapping
 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,
+    ServiceRequestTimeoutError,
     ServiceResponseError,
+    ServiceResponseTimeoutError,
 )
 from .._base_async import AsyncHttpTransport, _handle_non_stream_rest_response
 from .._base import _create_connection_config
@@ -52,6 +54,15 @@ if TYPE_CHECKING:
 CONTENT_CHUNK_SIZE = 10 * 1024
 _LOGGER = logging.getLogger(__name__)
 
+try:
+    # ConnectionTimeoutError was only introduced in aiohttp 3.10 so we want to keep this
+    # backwards compatible. If client is using aiohttp <3.10, the behaviour will safely
+    # fall back to treating a TimeoutError as a ServiceResponseError (that wont be retried).
+    from aiohttp.client_exceptions import ConnectionTimeoutError
+except ImportError:
+
+    class ConnectionTimeoutError(Exception): ...  # type: ignore[no-redef]
+
 
 class AioHttpTransport(AsyncHttpTransport):
     """AioHttp HTTP sender implementation.
@@ -71,6 +82,7 @@ class AioHttpTransport(AsyncHttpTransport):
             raise ValueError("session_owner cannot be False if no session is provided")
         self.connection_config = _create_connection_config(**kwargs)
         self._use_env_settings = kwargs.pop("use_env_settings", True)
+        self._has_been_opened = False
 
     async def __aenter__(self):
         await self.open()
@@ -86,23 +98,31 @@ class AioHttpTransport(AsyncHttpTransport):
 
     async def open(self):
         """Opens the connection."""
-        if not self.session and self._session_owner:
-            jar = aiohttp.DummyCookieJar()
-            clientsession_kwargs = {
-                "trust_env": self._use_env_settings,
-                "cookie_jar": jar,
-                "auto_decompress": False,
-            }
-            self.session = aiohttp.ClientSession(**clientsession_kwargs)
-        # pyright has trouble to understand that self.session is not None, since we raised at worst in the init
-        self.session = cast(aiohttp.ClientSession, self.session)
+        if self._has_been_opened and not self.session:
+            raise ValueError(
+                "HTTP transport has already been closed. "
+                "You may check if you're calling a function outside of the `async with` of your client creation, "
+                "or if you called `await close()` on your client already."
+            )
+        if not self.session:
+            if self._session_owner:
+                jar = aiohttp.DummyCookieJar()
+                clientsession_kwargs = {
+                    "trust_env": self._use_env_settings,
+                    "cookie_jar": jar,
+                    "auto_decompress": False,
+                }
+                self.session = aiohttp.ClientSession(**clientsession_kwargs)
+            else:
+                raise ValueError("session_owner cannot be False and no session is available")
+
+        self._has_been_opened = True
         await self.session.__aenter__()
 
     async def close(self):
         """Closes the connection."""
         if self._session_owner and self.session:
             await self.session.close()
-            self._session_owner = False
             self.session = None
 
     def _build_ssl_config(self, cert, verify):
@@ -221,11 +241,16 @@ class AioHttpTransport(AsyncHttpTransport):
             )
             if not stream:
                 await _handle_non_stream_rest_response(response)
-
+        except AttributeError as err:
+            if self.session is None:
+                raise ValueError("No session available for request.") from err
+            raise
         except aiohttp.client_exceptions.ClientResponseError as err:
             raise ServiceResponseError(err, error=err) from err
+        except ConnectionTimeoutError as err:
+            raise ServiceRequestTimeoutError(err, error=err) from err
         except asyncio.TimeoutError as err:
-            raise ServiceResponseError(err, error=err) from err
+            raise ServiceResponseTimeoutError(err, error=err) from err
         except aiohttp.client_exceptions.ClientError as err:
             raise ServiceRequestError(err, error=err) from err
         return response

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

@@ -24,18 +24,20 @@
 #
 # --------------------------------------------------------------------------
 import logging
-from typing import Optional, Union, TypeVar, cast, MutableMapping, TYPE_CHECKING
+from typing import Optional, Union, TypeVar, MutableMapping, TYPE_CHECKING
 from urllib3.util.retry import Retry
 from urllib3.exceptions import (
     ProtocolError,
     NewConnectionError,
     ConnectTimeoutError,
 )
-import requests  # pylint: disable=all
+import requests  # pylint: disable=networking-import-outside-azure-core-transport
 
 from ...exceptions import (
     ServiceRequestError,
+    ServiceRequestTimeoutError,
     ServiceResponseError,
+    ServiceResponseTimeoutError,
     IncompleteReadError,
     HttpResponseError,
 )
@@ -84,12 +86,13 @@ class RequestsTransport(HttpTransport):
             raise ValueError("session_owner cannot be False if no session is provided")
         self.connection_config = _create_connection_config(**kwargs)
         self._use_env_settings = kwargs.pop("use_env_settings", True)
+        self._has_been_opened = False
 
     def __enter__(self) -> "RequestsTransport":
         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:
@@ -106,19 +109,26 @@ class RequestsTransport(HttpTransport):
             session.mount(p, adapter)
 
     def open(self):
-        if not self.session and self._session_owner:
-            self.session = requests.Session()
-            self._init_session(self.session)
-        # pyright has trouble to understand that self.session is not None, since we raised at worst in the init
-        self.session = cast(requests.Session, self.session)
+        if self._has_been_opened and not self.session:
+            raise ValueError(
+                "HTTP transport has already been closed. "
+                "You may check if you're calling a function outside of the `with` of your client creation, "
+                "or if you called `close()` on your client already."
+            )
+        if not self.session:
+            if self._session_owner:
+                self.session = requests.Session()
+                self._init_session(self.session)
+            else:
+                raise ValueError("session_owner cannot be False and no session is available")
+        self._has_been_opened = True
 
     def close(self):
         if self._session_owner and self.session:
             self.session.close()
-            self._session_owner = False
             self.session = None
 
-    def send(
+    def send(  # pylint: disable=too-many-statements
         self,
         request: "RestHttpRequest",
         *,
@@ -165,13 +175,18 @@ class RequestsTransport(HttpTransport):
             )
             response.raw.enforce_content_length = True
 
-        except (
-            NewConnectionError,
-            ConnectTimeoutError,
-        ) as err:
+        except AttributeError as err:
+            if self.session is None:
+                raise ValueError("No session available for request.") from err
+            raise
+        except NewConnectionError as err:
             error = ServiceRequestError(err, error=err)
+        except ConnectTimeoutError as err:
+            error = ServiceRequestTimeoutError(err, error=err)
+        except requests.exceptions.ConnectTimeout as err:
+            error = ServiceRequestTimeoutError(err, error=err)
         except requests.exceptions.ReadTimeout as err:
-            error = ServiceResponseError(err, error=err)
+            error = ServiceResponseTimeoutError(err, error=err)
         except requests.exceptions.ConnectionError as err:
             if err.args and isinstance(err.args[0], ProtocolError):
                 error = ServiceResponseError(err, error=err)
@@ -180,13 +195,13 @@ class RequestsTransport(HttpTransport):
         except requests.exceptions.ChunkedEncodingError as err:
             msg = err.__str__()
             if "IncompleteRead" in msg:
-                _LOGGER.warning("Incomplete download: %s", err)
+                _LOGGER.warning("Incomplete download.")
                 error = IncompleteReadError(err, error=err)
             else:
-                _LOGGER.warning("Unable to stream download: %s", err)
+                _LOGGER.warning("Unable to stream download.")
                 error = HttpResponseError(err, error=err)
         except requests.RequestException as err:
-            error = ServiceRequestError(err, error=err)
+            error = ServiceResponseError(err, error=err)
 
         if error:
             raise error

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/utils/_utils.py

@@ -169,9 +169,10 @@ def get_file_items(files: "FilesType") -> Sequence[Tuple[str, "FileType"]]:
 
 def get_running_async_lock() -> AsyncContextManager:
     """Get a lock instance from the async library that the current context is running under.
+
     :return: An instance of the running async library's Lock class.
     :rtype: AsyncContextManager
-    :raises: RuntimeError if the current context is not running under an async library.
+    :raises RuntimeError: if the current context is not running under an async library.
     """
 
     try:

corehttp-1.0.0b7.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: corehttp
+Version: 1.0.0b7
+Summary: CoreHTTP Library for Python
+Home-page: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/core/corehttp
+Author: Microsoft Corporation
+Author-email: azpysdkhelp@microsoft.com
+License: MIT License
+Keywords: typespec,core
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing-extensions>=4.6.0
+Provides-Extra: requests
+Requires-Dist: requests>=2.18.4; extra == "requests"
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp>=3.0; extra == "aiohttp"
+Provides-Extra: httpx
+Requires-Dist: httpx>=0.25.0; extra == "httpx"
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api~=1.26; extra == "tracing"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# Core HTTP shared client library for Python
+
+`corehttp` provides shared exceptions and modules for Python SDK client libraries.
+
+## Getting started
+
+Typically, you will not need to install `corehttp`, as it will be installed when you install one of the client libraries using it.
+
+### Transports
+
+To use `corehttp`, you will need to choose a transport implementation. `corehttp` provides the following transports:
+
+Synchronous transports:
+- `RequestsTransport` - A synchronous transport based on the [Requests](https://requests.readthedocs.io/en/master/) library.
+- `HttpXTransport` - An synchronous transport based on the [HTTPX](https://www.python-httpx.org/) library.
+
+Asynchronous transports:
+- `AioHttpTransport` - An asynchronous transport based on the [aiohttp](https://docs.aiohttp.org/en/stable/) library.
+- `AsyncHttpXTransport` -  An asynchronous transport based on the [HTTPX](https://www.python-httpx.org/) library.
+
+Each transport has its own dependencies, which you can install using the `corehttp` extras:
+
+```bash
+# Install individually.
+pip install corehttp[requests]
+pip install corehttp[aiohttp]
+pip install corehttp[httpx]
+
+# Install multiple.
+pip install corehttp[requests,httpx]
+```
+
+If no transports are specified, `corehttp` will default to using `RequestsTransport` for synchronous pipeline requests and `AioHttpTransport` for asynchronous pipeline requests.
+
+## Contributing
+
+This project welcomes contributions and suggestions. Most contributions require
+you to agree to a Contributor License Agreement (CLA) declaring that you have
+the right to, and actually do, grant us the rights to use your contribution.
+For details, visit [https://cla.microsoft.com](https://cla.microsoft.com).
+
+When you submit a pull request, a CLA-bot will automatically determine whether
+you need to provide a CLA and decorate the PR appropriately (e.g., label,
+comment). Simply follow the instructions provided by the bot. You will only
+need to do this once across all repos using our CLA.
+
+This project has adopted the
+[Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information, see the
+[Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any
+additional questions or comments.
+
+
+
+
+# Release History
+
+## 1.0.0b7 (2026-02-05)
+
+### Features Added
+
+- Native tracing support was added. [#39172](https://github.com/Azure/azure-sdk-for-python/pull/39172)
+  - The `OpenTelemetryTracer` class was added to the `corehttp.instrumentation.tracing.opentelemetry` module. This is a wrapper around the OpenTelemetry tracer that is used to create spans for SDK operations.
+  - Added a `get_tracer` method to the new `corehttp.instrumentation` module. This method returns an instance of the `OpenTelemetryTracer` class if OpenTelemetry is available.
+  - A `TracingOptions` TypedDict class was added to define the options that SDK users can use to configure tracing per-operation. These options include the ability to enable or disable tracing and set additional attributes on spans.
+    - Example usage: `client.method(tracing_options={"enabled": True, "attributes": {"foo": "bar"}})`
+  - `DistributedHttpTracingPolicy` and `distributed_trace`/`distributed_trace_async` decorators were added to support OpenTelemetry tracing for SDK operations.
+    - SDK clients can define an `_instrumentation_config` class variable to configure the OpenTelemetry tracer used in method span creation. Possible configuration options are `library_name`, `library_version`, `schema_url`, and `attributes`.
+- Added a global settings object, `corehttp.settings`, to the `corehttp` package. This object can be used to set global settings for the `corehttp` package. Currently the only setting is `tracing_enabled` for enabling/disabling tracing. [#39172](https://github.com/Azure/azure-sdk-for-python/pull/39172)
+- Added `start_time` and `context` keyword arguments to `OpenTelemetryTracer.start_span` and `start_as_current_span` methods.
+- Added `set_span_error_status` static method to `OpenTelemetryTracer` for setting a span's status to ERROR.
+- Added `is_generated_model`, `attribute_list`, and `TypeHandlerRegistry` to `corehttp.serialization` module for SDK model handling.
+
+### Bugs Fixed
+
+- Fixed `retry_backoff_max` being ignored in retry policies when configuring retries.
+- Raise correct exception if transport is used while already closed.
+- A timeout error when using the `aiohttp` transport will now be raised as a `corehttp.exceptions.ServiceResponseTimeoutError`, a subtype of the previously raised `ServiceResponseError`.
+- When using with `aiohttp` 3.10 or later, a connection timeout error will now be raised as a `corehttp.exceptions.ServiceRequestTimeoutError`, which can be retried.
+- Fixed leaked requests and aiohttp exceptions for streamed responses.
+- Improved granularity of `ServiceRequestError` and `ServiceResponseError` exceptions raised in timeout scenarios from the requests and aiohttp transports.
+- `BearerTokenCredentialPolicy` and `AsyncBearerTokenCredentialPolicy` will now properly chain exceptions raised during claims challenge handling. If a credential raises an exception when attempting to acquire a token in response to a claims challenge, that exception will be raised with the original 401 response as the cause.
+
+### Other Changes
+
+- Added `opentelemetry-api` as an optional dependency for tracing. [#39172](https://github.com/Azure/azure-sdk-for-python/pull/39172)
+
+## 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
+
+- Accept float for `retry_after` header.
+
+## 1.0.0b4 (2024-02-23)
+
+### Other Changes
+
+- Relax type checking in `Pipeline` constructors to only check that each user-supplied policy object has either a `send` method or both an `on_request` and `on_response` method. This allows for more flexible policy implementations. [#34296](https://github.com/Azure/azure-sdk-for-python/pull/34296)
+
+## 1.0.0b3 (2024-02-01)
+
+### Features Added
+
+- Support tuple input for `files` values to `corehttp.rest.HttpRequest` #34082
+- Support simultaneous `files` and `data` field entry into `corehttp.rest.HttpRequest` #34082
+
+## 1.0.0b2 (2023-11-14)
+
+### Features Added
+
+- Added the initial implementation of the HTTPX transport. [#32813](https://github.com/Azure/azure-sdk-for-python/pull/32813)
+
+### Breaking Changes
+
+- Removed `requests` as a default dependency of `corehttp`. This is now an "extras" dependency and can be installed via `corehttp[requests]`. [#32813](https://github.com/Azure/azure-sdk-for-python/pull/32813)
+- Renamed the `aio` extra to `aiohttp`. [#32813](https://github.com/Azure/azure-sdk-for-python/pull/32813)
+
+### Bugs Fixed
+
+- Fixed an issue with `multipart/form-data` in the async transport where `data` was not getting encoded into the request body. [#32473](https://github.com/Azure/azure-sdk-for-python/pull/32473)
+- Fixed an issue with `connection_verify`, `connection_cert`, and `connection_timeout` not being propagated to underlying transports.  [#33057](https://github.com/Azure/azure-sdk-for-python/pull/33057)
+- Fixed an issue with the `aiohttp` transport not using SSL by default. [#33057](https://github.com/Azure/azure-sdk-for-python/pull/33057)
+
+### Other Changes
+
+- Added extras for `httpx`. [#32813](https://github.com/Azure/azure-sdk-for-python/pull/32813)
+
+## 1.0.0b1 (2023-10-18)
+
+* Initial Release

corehttp-1.0.0b7.dist-info/RECORD

@@ -0,0 +1,61 @@
+corehttp/__init__.py,sha256=Wdidh085sV_IhdV_wU79t7FpghhpyxCsRnZGOUoQ0xs,1443
+corehttp/_match_conditions.py,sha256=3TIhb4vBO1hBe7MaQwS_9i-d6p7o4jn5L6M-OiQahkg,1864
+corehttp/_version.py,sha256=VyIft7_Im1KeJZKTuvpUbQW8Bf73j9wwDlOmTytSBiM,494
+corehttp/credentials.py,sha256=0_-W5sMBrrZmHEcv4h51lvAwWNCZBf3tvkslNPgZgo0,7018
+corehttp/exceptions.py,sha256=mKh6wtuYi2aqiZRicNjE_693gBJMkNaWJLuXJ-VE444,11658
+corehttp/paging.py,sha256=H-ctDDRWtp8i3R7xZwFQQEK-5YGNYHSAtk8hdg99efs,10039
+corehttp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+corehttp/serialization.py,sha256=MeQVSOpzlzcf4BomkyF3eVjETciABEN75e8sT0Bsakk,13422
+corehttp/settings.py,sha256=7kEnzs09jAHYytt59BGHh8g10y2YHlP7j3SkrTMpD6c,1618
+corehttp/instrumentation/__init__.py,sha256=_zOuDpRLiAvHgJIHcpgI-w-ZVmFZ8Ucl5ikdWnNVVsE,224
+corehttp/instrumentation/tracing/__init__.py,sha256=y6FMPOMDsFwyQNWtpf0KJsemYpvU_sGuWuZ309k0yB4,391
+corehttp/instrumentation/tracing/_decorator.py,sha256=tPiN_C0hEqLAgm4IqRY4-gaJllnsLpVTJcGVg95gmlE,7402
+corehttp/instrumentation/tracing/_models.py,sha256=4RPQ9uQUiLepRnQGLUxWy8-Ohi7JWhmAT1qvFZKNcF0,2273
+corehttp/instrumentation/tracing/_tracer.py,sha256=-q5DMsbAz5L_sD3NrpPf991o4ggC4G9d4iFcmxM5Gx8,2443
+corehttp/instrumentation/tracing/opentelemetry.py,sha256=VTAPfgppUkDkyVg30SwwYYfg5ub2raC3FpzqsVLnzuA,10729
+corehttp/instrumentation/tracing/utils.py,sha256=TIwtUo4BizEIg-HnwCQX0L24yVWAh8X7NV5lmZKvCFI,819
+corehttp/rest/__init__.py,sha256=GwPFwVYZ9aa4DI9f2-oQGr2nfF7wXvVL80V51ymAjAk,1467
+corehttp/rest/_aiohttp.py,sha256=uZmU5CgzKhIjsQd6dEG6HUiRgpgiqFa_GCO4SSqsfX8,11965
+corehttp/rest/_helpers.py,sha256=ZhXhAiAw8DW_gxUPE3tumMplRS1Jt2h6joLVsk-u6yI,7897
+corehttp/rest/_http_response_impl.py,sha256=REWjOWJERB-EBtU2SSilGd3L1wSKCf-jWeTUj6Q6Z0g,11284
+corehttp/rest/_http_response_impl_async.py,sha256=QAcrTYMH1Sp9R5cVQOFrRnZli7wEzjd5Fv9rlJdmDsc,4974
+corehttp/rest/_httpx.py,sha256=dPmiEsB29_Auocm4EdmjIuMjF55zbPjdmk1YjqliJTE,8079
+corehttp/rest/_requests_basic.py,sha256=c2zRx79AMd-gdWwwVZAqxIBSLSoJx8fedQCoQI_ofaQ,7985
+corehttp/rest/_rest_py3.py,sha256=Pj9HfktnJIPIr5lTUpNNIlC-ZU5pXRdX-tRD29yVjOo,14033
+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=LYUDTtHlJ0XOIgraCjk-y9BGjwnNtXWpy-gQg2ufV_Q,7732
+corehttp/runtime/pipeline/_base.py,sha256=FJfhSKy9eaQtmBYllqahfZxYHLGx_S4RocVSN8Sdhpk,6952
+corehttp/runtime/pipeline/_base_async.py,sha256=cBiLHuRsg6poISOvu9lfBl5anXowkN7RGzuIGBfXOhw,7381
+corehttp/runtime/pipeline/_tools.py,sha256=E351oLFCdM9e4jP-CANESD8rifChOTH_W0bapwZndr0,2502
+corehttp/runtime/pipeline/_tools_async.py,sha256=r9Apyo4BOTKSRTfyFjLmcrGiVoulrnpxqkNOmzHOrGg,2151
+corehttp/runtime/policies/__init__.py,sha256=fPT19op2ZlTQJ7jLpaMCZeruB0Ip2Ex_a7uY5wUHxG0,2295
+corehttp/runtime/policies/_authentication.py,sha256=5n4gKzTAJDQBc65U8zI5ezqJEsYNSNRaAGH4W0BGzo8,11632
+corehttp/runtime/policies/_authentication_async.py,sha256=lz4bJh2u6Er7qdgwq2ejXtDDUqS2Qvbq7W_VaOfVNFQ,9356
+corehttp/runtime/policies/_base.py,sha256=zLM4NIwGQwZ75k-KPo3PthmDCpDidHvZy91ok0wnFvQ,5063
+corehttp/runtime/policies/_base_async.py,sha256=nOZ-3lrKmfnFam3FbSY4wd9sOI7r5pI2HSdqgOC4Vz4,2531
+corehttp/runtime/policies/_distributed_tracing.py,sha256=Fky-cFTAiiHeTdarYf6GS8Iq_rbwngun-eTKk7ilxGY,6675
+corehttp/runtime/policies/_retry.py,sha256=Tr_9R_sWNcPrnPUYoakAEqpaY9d1to6T5Lf216xk0Ts,24393
+corehttp/runtime/policies/_retry_async.py,sha256=-g7ZeqarL-5d7MFSDylvyBTLsy8PRazUY5Nz83Qm8co,9122
+corehttp/runtime/policies/_universal.py,sha256=LlE5AIDo3rFn0u6qSNfwCKiLQMuiL2jW4eQpPVIkue0,20028
+corehttp/runtime/policies/_utils.py,sha256=kDnGRpC3MxsW7zHZRfkLyPMArlzY4n7vBhwQQVWKQuI,3596
+corehttp/transport/__init__.py,sha256=6A1i9gjM5isBPb-AL-2JTzxn7pssDj8ux9Ujn6rHjlY,1442
+corehttp/transport/_base.py,sha256=qsIG3LX6xZpSmJaPVxtlJNePW62Uyl1gmoCQOsM_GoI,5048
+corehttp/transport/_base_async.py,sha256=BuoHO2gas9k9qBKW5WiY_taLO9tr-MovkBY-1sOrTCM,3762
+corehttp/transport/aiohttp/__init__.py,sha256=gdCazQ9XMZ6xgJCakm4efxECBFU-IIxKuMF3VmM9dHQ,1381
+corehttp/transport/aiohttp/_aiohttp.py,sha256=M91Yda3dAdLqk8-dWXyISkf3oZBVdLmnp45CCseoFVA,10800
+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=S1zE3v6QwPtdEm2cLdu8B5iW5WbETTgpv0datZ9g_eo,2487
+corehttp/transport/requests/_requests_basic.py,sha256=ZMAQv9jFeomXiOn0v16qUP7iUq3J67pbiKBVEq3H9Ts,8948
+corehttp/utils/__init__.py,sha256=_h2vJje1Tb-w_9mXm0hO_s2S1b48HLzI4taIlvz3Eu4,1648
+corehttp/utils/_enum_meta.py,sha256=9rdoxCOiBnYFMUC8-8_yaoCA9s_GdbIkguxk3Z71iyM,2774
+corehttp/utils/_utils.py,sha256=ZSp4H0TBKFZzIXav7-WwadirC3FLjdk8mTWI7fWE19A,6064
+corehttp-1.0.0b7.dist-info/licenses/LICENSE,sha256=_VMkgdgo4ToLE8y1mOAjOKNhd0BnWoYu5r3BVBto6T0,1073
+corehttp-1.0.0b7.dist-info/METADATA,sha256=2CTz5IW8LveWt7D3JkssRH3KrCKYnKe9rkSIOLRnXjk,11139
+corehttp-1.0.0b7.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+corehttp-1.0.0b7.dist-info/top_level.txt,sha256=NAGJ-rIA_vW2ZJghxC5NqIbnfrXDBMmE-TAd-9ud4i4,9
+corehttp-1.0.0b7.dist-info/RECORD,,

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

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