adsk-platform-httpclient 0.2.9__tar.gz

adsk_platform_httpclient-0.2.9/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: adsk-platform-httpclient
+Version: 0.2.9
+Summary: Autodesk Platform Services: shared HTTP client and authentication utilities for Kiota-based SDKs
+Author: duszykf
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Autodesk/APS-SDK-Kiota
+Project-URL: Repository, https://github.com/Autodesk/APS-SDK-Kiota
+Project-URL: Issues, https://github.com/Autodesk/APS-SDK-Kiota/issues
+Keywords: autodesk,aps,kiota,sdk,httpclient
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: microsoft-kiota-abstractions<2.0.0,>=1.9.0
+Requires-Dist: microsoft-kiota-http<2.0.0,>=1.9.0
+Requires-Dist: httpx<1.0.0,>=0.27.0
+
+# adsk-platform-httpclient
+
+Shared HTTP client, authentication, and middleware utilities for [Autodesk Platform Services](https://aps.autodesk.com/) Python SDKs.
+
+This package provides the foundational components used by all `adsk-platform-*` SDK packages.
+
+## Installation
+
+```bash
+pip install adsk-platform-httpclient
+```
+
+> **Note:** You typically don't need to install this package directly. It's automatically included as a dependency of the SDK packages (e.g., `adsk-platform-acc`, `adsk-platform-data-management`).
+
+## Components
+
+### HttpClientFactory
+
+Creates pre-configured `httpx.AsyncClient` instances and Kiota request adapters with bearer-token authentication and the custom middleware pipeline.
+
+```python
+from autodesk_common_httpclient import HttpClientFactory
+
+async def get_access_token() -> str:
+    return "YOUR_ACCESS_TOKEN"
+
+# Create a Kiota request adapter with authentication + middleware
+adapter = HttpClientFactory.create_adapter(get_access_token)
+
+# Or provide your own httpx client
+import httpx
+custom_client = httpx.AsyncClient(timeout=60.0)
+adapter = HttpClientFactory.create_adapter(get_access_token, http_client=custom_client)
+```
+
+### AccessTokenProviderCallback
+
+Wraps an async callback into a Kiota-compatible `AccessTokenProvider`.
+
+```python
+from autodesk_common_httpclient import AccessTokenProviderCallback
+
+provider = AccessTokenProviderCallback(get_access_token)
+```
+
+## Custom Middleware
+
+The package includes three custom middleware handlers that are automatically added to the HTTP pipeline, matching the C# `Autodesk.Common.HttpClientLibrary.Middleware`:
+
+### ErrorHandler
+
+Raises an `httpx.HTTPStatusError` when the HTTP response has a non-success status code (4xx/5xx). Enabled by default.
+
+```python
+from autodesk_common_httpclient import ErrorHandlerOption
+
+# Disable for a specific request
+error_option = ErrorHandlerOption(enabled=False)
+```
+
+### QueryParameterHandler
+
+Appends or overwrites query parameters on every outgoing request. Useful for injecting API versions, region codes, or tracking identifiers.
+
+```python
+from autodesk_common_httpclient import QueryParameterHandlerOption
+
+query_option = QueryParameterHandlerOption(query_parameters={"region": "US"})
+```
+
+### RateLimitingHandler
+
+Limits the number of concurrent requests per endpoint within a sliding time window. Disabled by default.
+
+```python
+from autodesk_common_httpclient import RateLimitingHandlerOption
+
+# Allow max 10 requests per endpoint per 60 seconds
+rate_option = RateLimitingHandlerOption()
+rate_option.set_rate_limit(max_requests=10, time_window_seconds=60.0)
+```
+
+### Creating a client with rate limiting
+
+```python
+from autodesk_common_httpclient import HttpClientFactory
+
+# Create an HTTP client with rate limiting enabled
+client = HttpClientFactory.create_with_rate_limit(
+    max_requests=10,
+    time_window_seconds=60.0,
+)
+
+# Use it with any SDK client
+adapter = HttpClientFactory.create_adapter(get_access_token, http_client=client)
+```
+
+### Middleware Pipeline Order
+
+The middleware is executed in this order (matching the C# implementation):
+
+1. **Kiota defaults** — Redirect, Retry, Parameters Name Decoding, URL Replace, User Agent, Headers Inspection
+2. **RateLimitingHandler** — Per-endpoint rate limiting
+3. **QueryParameterHandler** — Query parameter injection
+4. **ErrorHandler** — Error response detection
+
+## Requirements
+
+- Python 3.10 or later
+
+## License
+
+This project is licensed under the MIT License.

adsk_platform_httpclient-0.2.9/README.md

@@ -0,0 +1,113 @@
+# adsk-platform-httpclient
+
+Shared HTTP client, authentication, and middleware utilities for [Autodesk Platform Services](https://aps.autodesk.com/) Python SDKs.
+
+This package provides the foundational components used by all `adsk-platform-*` SDK packages.
+
+## Installation
+
+```bash
+pip install adsk-platform-httpclient
+```
+
+> **Note:** You typically don't need to install this package directly. It's automatically included as a dependency of the SDK packages (e.g., `adsk-platform-acc`, `adsk-platform-data-management`).
+
+## Components
+
+### HttpClientFactory
+
+Creates pre-configured `httpx.AsyncClient` instances and Kiota request adapters with bearer-token authentication and the custom middleware pipeline.
+
+```python
+from autodesk_common_httpclient import HttpClientFactory
+
+async def get_access_token() -> str:
+    return "YOUR_ACCESS_TOKEN"
+
+# Create a Kiota request adapter with authentication + middleware
+adapter = HttpClientFactory.create_adapter(get_access_token)
+
+# Or provide your own httpx client
+import httpx
+custom_client = httpx.AsyncClient(timeout=60.0)
+adapter = HttpClientFactory.create_adapter(get_access_token, http_client=custom_client)
+```
+
+### AccessTokenProviderCallback
+
+Wraps an async callback into a Kiota-compatible `AccessTokenProvider`.
+
+```python
+from autodesk_common_httpclient import AccessTokenProviderCallback
+
+provider = AccessTokenProviderCallback(get_access_token)
+```
+
+## Custom Middleware
+
+The package includes three custom middleware handlers that are automatically added to the HTTP pipeline, matching the C# `Autodesk.Common.HttpClientLibrary.Middleware`:
+
+### ErrorHandler
+
+Raises an `httpx.HTTPStatusError` when the HTTP response has a non-success status code (4xx/5xx). Enabled by default.
+
+```python
+from autodesk_common_httpclient import ErrorHandlerOption
+
+# Disable for a specific request
+error_option = ErrorHandlerOption(enabled=False)
+```
+
+### QueryParameterHandler
+
+Appends or overwrites query parameters on every outgoing request. Useful for injecting API versions, region codes, or tracking identifiers.
+
+```python
+from autodesk_common_httpclient import QueryParameterHandlerOption
+
+query_option = QueryParameterHandlerOption(query_parameters={"region": "US"})
+```
+
+### RateLimitingHandler
+
+Limits the number of concurrent requests per endpoint within a sliding time window. Disabled by default.
+
+```python
+from autodesk_common_httpclient import RateLimitingHandlerOption
+
+# Allow max 10 requests per endpoint per 60 seconds
+rate_option = RateLimitingHandlerOption()
+rate_option.set_rate_limit(max_requests=10, time_window_seconds=60.0)
+```
+
+### Creating a client with rate limiting
+
+```python
+from autodesk_common_httpclient import HttpClientFactory
+
+# Create an HTTP client with rate limiting enabled
+client = HttpClientFactory.create_with_rate_limit(
+    max_requests=10,
+    time_window_seconds=60.0,
+)
+
+# Use it with any SDK client
+adapter = HttpClientFactory.create_adapter(get_access_token, http_client=client)
+```
+
+### Middleware Pipeline Order
+
+The middleware is executed in this order (matching the C# implementation):
+
+1. **Kiota defaults** — Redirect, Retry, Parameters Name Decoding, URL Replace, User Agent, Headers Inspection
+2. **RateLimitingHandler** — Per-endpoint rate limiting
+3. **QueryParameterHandler** — Query parameter injection
+4. **ErrorHandler** — Error response detection
+
+## Requirements
+
+- Python 3.10 or later
+
+## License
+
+This project is licensed under the MIT License.

adsk_platform_httpclient-0.2.9/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "adsk-platform-httpclient"
+version = "0.2.9"
+description = "Autodesk Platform Services: shared HTTP client and authentication utilities for Kiota-based SDKs"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "duszykf" },
+]
+keywords = [
+    "autodesk",
+    "aps",
+    "kiota",
+    "sdk",
+    "httpclient",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    "microsoft-kiota-abstractions>=1.9.0,<2.0.0",
+    "microsoft-kiota-http>=1.9.0,<2.0.0",
+    "httpx>=0.27.0,<1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Autodesk/APS-SDK-Kiota"
+Repository = "https://github.com/Autodesk/APS-SDK-Kiota"
+Issues = "https://github.com/Autodesk/APS-SDK-Kiota/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

adsk_platform_httpclient-0.2.9/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

adsk_platform_httpclient-0.2.9/src/adsk_platform_httpclient.egg-info/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: adsk-platform-httpclient
+Version: 0.2.9
+Summary: Autodesk Platform Services: shared HTTP client and authentication utilities for Kiota-based SDKs
+Author: duszykf
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Autodesk/APS-SDK-Kiota
+Project-URL: Repository, https://github.com/Autodesk/APS-SDK-Kiota
+Project-URL: Issues, https://github.com/Autodesk/APS-SDK-Kiota/issues
+Keywords: autodesk,aps,kiota,sdk,httpclient
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: microsoft-kiota-abstractions<2.0.0,>=1.9.0
+Requires-Dist: microsoft-kiota-http<2.0.0,>=1.9.0
+Requires-Dist: httpx<1.0.0,>=0.27.0
+
+# adsk-platform-httpclient
+
+Shared HTTP client, authentication, and middleware utilities for [Autodesk Platform Services](https://aps.autodesk.com/) Python SDKs.
+
+This package provides the foundational components used by all `adsk-platform-*` SDK packages.
+
+## Installation
+
+```bash
+pip install adsk-platform-httpclient
+```
+
+> **Note:** You typically don't need to install this package directly. It's automatically included as a dependency of the SDK packages (e.g., `adsk-platform-acc`, `adsk-platform-data-management`).
+
+## Components
+
+### HttpClientFactory
+
+Creates pre-configured `httpx.AsyncClient` instances and Kiota request adapters with bearer-token authentication and the custom middleware pipeline.
+
+```python
+from autodesk_common_httpclient import HttpClientFactory
+
+async def get_access_token() -> str:
+    return "YOUR_ACCESS_TOKEN"
+
+# Create a Kiota request adapter with authentication + middleware
+adapter = HttpClientFactory.create_adapter(get_access_token)
+
+# Or provide your own httpx client
+import httpx
+custom_client = httpx.AsyncClient(timeout=60.0)
+adapter = HttpClientFactory.create_adapter(get_access_token, http_client=custom_client)
+```
+
+### AccessTokenProviderCallback
+
+Wraps an async callback into a Kiota-compatible `AccessTokenProvider`.
+
+```python
+from autodesk_common_httpclient import AccessTokenProviderCallback
+
+provider = AccessTokenProviderCallback(get_access_token)
+```
+
+## Custom Middleware
+
+The package includes three custom middleware handlers that are automatically added to the HTTP pipeline, matching the C# `Autodesk.Common.HttpClientLibrary.Middleware`:
+
+### ErrorHandler
+
+Raises an `httpx.HTTPStatusError` when the HTTP response has a non-success status code (4xx/5xx). Enabled by default.
+
+```python
+from autodesk_common_httpclient import ErrorHandlerOption
+
+# Disable for a specific request
+error_option = ErrorHandlerOption(enabled=False)
+```
+
+### QueryParameterHandler
+
+Appends or overwrites query parameters on every outgoing request. Useful for injecting API versions, region codes, or tracking identifiers.
+
+```python
+from autodesk_common_httpclient import QueryParameterHandlerOption
+
+query_option = QueryParameterHandlerOption(query_parameters={"region": "US"})
+```
+
+### RateLimitingHandler
+
+Limits the number of concurrent requests per endpoint within a sliding time window. Disabled by default.
+
+```python
+from autodesk_common_httpclient import RateLimitingHandlerOption
+
+# Allow max 10 requests per endpoint per 60 seconds
+rate_option = RateLimitingHandlerOption()
+rate_option.set_rate_limit(max_requests=10, time_window_seconds=60.0)
+```
+
+### Creating a client with rate limiting
+
+```python
+from autodesk_common_httpclient import HttpClientFactory
+
+# Create an HTTP client with rate limiting enabled
+client = HttpClientFactory.create_with_rate_limit(
+    max_requests=10,
+    time_window_seconds=60.0,
+)
+
+# Use it with any SDK client
+adapter = HttpClientFactory.create_adapter(get_access_token, http_client=client)
+```
+
+### Middleware Pipeline Order
+
+The middleware is executed in this order (matching the C# implementation):
+
+1. **Kiota defaults** — Redirect, Retry, Parameters Name Decoding, URL Replace, User Agent, Headers Inspection
+2. **RateLimitingHandler** — Per-endpoint rate limiting
+3. **QueryParameterHandler** — Query parameter injection
+4. **ErrorHandler** — Error response detection
+
+## Requirements
+
+- Python 3.10 or later
+
+## License
+
+This project is licensed under the MIT License.

adsk_platform_httpclient-0.2.9/src/adsk_platform_httpclient.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+src/adsk_platform_httpclient.egg-info/PKG-INFO
+src/adsk_platform_httpclient.egg-info/SOURCES.txt
+src/adsk_platform_httpclient.egg-info/dependency_links.txt
+src/adsk_platform_httpclient.egg-info/requires.txt
+src/adsk_platform_httpclient.egg-info/top_level.txt
+src/autodesk_common_httpclient/__init__.py
+src/autodesk_common_httpclient/access_token_provider.py
+src/autodesk_common_httpclient/http_client_factory.py
+src/autodesk_common_httpclient/middleware/__init__.py
+src/autodesk_common_httpclient/middleware/error_handler.py
+src/autodesk_common_httpclient/middleware/query_parameter_handler.py
+src/autodesk_common_httpclient/middleware/rate_limiting_handler.py
+src/autodesk_common_httpclient/middleware/options/__init__.py
+src/autodesk_common_httpclient/middleware/options/error_handler_option.py
+src/autodesk_common_httpclient/middleware/options/query_parameter_handler_option.py
+src/autodesk_common_httpclient/middleware/options/rate_limiting_handler_option.py

adsk_platform_httpclient-0.2.9/src/adsk_platform_httpclient.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

adsk_platform_httpclient-0.2.9/src/adsk_platform_httpclient.egg-info/requires.txt

@@ -0,0 +1,3 @@
+microsoft-kiota-abstractions<2.0.0,>=1.9.0
+microsoft-kiota-http<2.0.0,>=1.9.0
+httpx<1.0.0,>=0.27.0

adsk_platform_httpclient-0.2.9/src/adsk_platform_httpclient.egg-info/top_level.txt

@@ -0,0 +1 @@
+autodesk_common_httpclient

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/__init__.py

@@ -0,0 +1,28 @@
+"""Autodesk Platform Services: shared HTTP client utilities for Kiota-based SDKs."""
+
+from autodesk_common_httpclient.access_token_provider import AccessTokenProviderCallback
+from autodesk_common_httpclient.http_client_factory import HttpClientFactory
+from autodesk_common_httpclient.middleware import (
+    ErrorContext,
+    ErrorHandler,
+    QueryParameterHandler,
+    RateLimitingHandler,
+)
+from autodesk_common_httpclient.middleware.options import (
+    ErrorHandlerOption,
+    QueryParameterHandlerOption,
+    RateLimitingHandlerOption,
+)
+
+__all__ = [
+    "AccessTokenProviderCallback",
+    "ErrorContext",
+    "ErrorHandler",
+    "ErrorHandlerOption",
+    "HttpClientFactory",
+    "QueryParameterHandler",
+    "QueryParameterHandlerOption",
+    "RateLimitingHandler",
+    "RateLimitingHandlerOption",
+]
+__version__ = "0.1.0"

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/access_token_provider.py

@@ -0,0 +1,49 @@
+"""Access token provider that wraps an async callback for Kiota authentication."""
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from kiota_abstractions.authentication import (
+    AccessTokenProvider,
+    AllowedHostsValidator,
+)
+
+
+class AccessTokenProviderCallback(AccessTokenProvider):
+    """Wraps an async callback into a Kiota-compatible :class:`AccessTokenProvider`.
+
+    This is the Python equivalent of the C# ``AccessTokenProvider`` class that wraps
+    a ``Func<Task<string>>`` delegate.
+
+    Args:
+        get_access_token: An async callable that returns a valid access token string.
+
+    Example::
+
+        async def my_token_provider() -> str:
+            return "my-access-token"
+
+        provider = AccessTokenProviderCallback(my_token_provider)
+    """
+
+    def __init__(self, get_access_token: Callable[[], Awaitable[str]]) -> None:
+        self._get_access_token = get_access_token
+
+    async def get_authorization_token(
+        self, uri: str, additional_authentication_context: dict[str, Any] = {}
+    ) -> str:
+        """Return the access token by invoking the wrapped callback.
+
+        Args:
+            uri: The target URI (ignored — the same token is used for all hosts).
+            additional_authentication_context: Additional context (ignored).
+
+        Returns:
+            The access token string.
+        """
+        return await self._get_access_token()
+
+    def get_allowed_hosts_validator(self) -> AllowedHostsValidator:
+        """Return an :class:`AllowedHostsValidator` that allows all hosts."""
+        return AllowedHostsValidator([])

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/http_client_factory.py

@@ -0,0 +1,170 @@
+"""Factory for creating Kiota request adapters with Autodesk authentication and middleware.
+
+This is the Python equivalent of the C# ``Autodesk.Common.HttpClientLibrary.HttpClientFactory``.
+"""
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Optional
+
+import httpx
+from kiota_abstractions.authentication import BaseBearerTokenAuthenticationProvider
+from kiota_abstractions.request_option import RequestOption
+from kiota_http.httpx_request_adapter import HttpxRequestAdapter
+from kiota_http.kiota_client_factory import KiotaClientFactory
+from kiota_http.middleware.middleware import BaseMiddleware
+
+from autodesk_common_httpclient.access_token_provider import AccessTokenProviderCallback
+from autodesk_common_httpclient.middleware.error_handler import ErrorHandler
+from autodesk_common_httpclient.middleware.options.error_handler_option import ErrorHandlerOption
+from autodesk_common_httpclient.middleware.options.query_parameter_handler_option import (
+    QueryParameterHandlerOption,
+)
+from autodesk_common_httpclient.middleware.options.rate_limiting_handler_option import (
+    RateLimitingHandlerOption,
+)
+from autodesk_common_httpclient.middleware.query_parameter_handler import QueryParameterHandler
+from autodesk_common_httpclient.middleware.rate_limiting_handler import RateLimitingHandler
+
+
+class HttpClientFactory:
+    """Creates pre-configured HTTP clients and Kiota request adapters.
+
+    This mirrors the C# ``HttpClientFactory`` from ``Autodesk.Common.HttpClientLibrary``,
+    including the custom middleware pipeline:
+
+    1. Kiota default handlers (redirect, retry, parameters name decoding, etc.)
+    2. **RateLimitingHandler** — per-endpoint sliding-window rate limiter
+    3. **QueryParameterHandler** — injects additional query parameters
+    4. **ErrorHandler** — raises on non-success HTTP responses
+    """
+
+    @staticmethod
+    def create(
+        http_client: Optional[httpx.AsyncClient] = None,
+        options: Optional[dict[str, RequestOption]] = None,
+    ) -> httpx.AsyncClient:
+        """Create an ``httpx.AsyncClient`` with Kiota default + Autodesk custom middleware.
+
+        Args:
+            http_client: An existing client to wrap. If ``None``, a new client
+                is created.
+            options: Optional dict of :class:`RequestOption` keyed by option key.
+                Recognised keys: ``RateLimitingHandlerOption``,
+                ``QueryParameterHandlerOption``, ``ErrorHandlerOption``.
+
+        Returns:
+            A configured :class:`httpx.AsyncClient` with the full middleware pipeline.
+        """
+        # Resolve options (fall back to defaults)
+        rate_limit_option = RateLimitingHandlerOption()
+        query_param_option = QueryParameterHandlerOption()
+        error_option = ErrorHandlerOption()
+
+        if options:
+            opt = options.get(RateLimitingHandlerOption.get_key())
+            if isinstance(opt, RateLimitingHandlerOption):
+                rate_limit_option = opt
+
+            opt = options.get(QueryParameterHandlerOption.get_key())
+            if isinstance(opt, QueryParameterHandlerOption):
+                query_param_option = opt
+
+            opt = options.get(ErrorHandlerOption.get_key())
+            if isinstance(opt, ErrorHandlerOption):
+                error_option = opt
+
+        # Build the middleware list: Kiota defaults + custom handlers
+        middleware = KiotaClientFactory.get_default_middleware(options)
+        middleware.extend([
+            RateLimitingHandler(rate_limit_option),
+            QueryParameterHandler(query_param_option),
+            ErrorHandler(error_option),
+        ])
+
+        client = http_client or KiotaClientFactory.get_default_client()
+        return KiotaClientFactory.create_with_custom_middleware(middleware, client)
+
+    @staticmethod
+    def create_with_rate_limit(
+        max_requests: int,
+        time_window_seconds: float,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> httpx.AsyncClient:
+        """Create an ``httpx.AsyncClient`` with rate limiting enabled.
+
+        Args:
+            max_requests: Maximum requests per endpoint within the time window.
+            time_window_seconds: Duration of the sliding window in seconds.
+            http_client: Optional existing client to wrap.
+
+        Returns:
+            A configured :class:`httpx.AsyncClient`.
+        """
+        rate_option = RateLimitingHandlerOption()
+        rate_option.set_rate_limit(max_requests, time_window_seconds)
+        return HttpClientFactory.create(
+            http_client,
+            options={RateLimitingHandlerOption.get_key(): rate_option},
+        )
+
+    @staticmethod
+    def create_adapter(
+        get_access_token: Callable[[], Awaitable[str]],
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> HttpxRequestAdapter:
+        """Create a :class:`HttpxRequestAdapter` with bearer-token auth and custom middleware.
+
+        This is the Python equivalent of the C#
+        ``HttpClientFactory.CreateAdapter(Func<Task<string>>, HttpClient?)``.
+
+        Args:
+            get_access_token: An async callable returning an access token string.
+            http_client: Optional :class:`httpx.AsyncClient`. If ``None``, a new
+                client with the full middleware pipeline is created.
+
+        Returns:
+            A ready-to-use :class:`HttpxRequestAdapter`.
+        """
+        auth = BaseBearerTokenAuthenticationProvider(
+            AccessTokenProviderCallback(get_access_token)
+        )
+        client = HttpClientFactory.create(http_client)
+        return HttpxRequestAdapter(auth, http_client=client)
+
+    @staticmethod
+    def get_default_middleware(
+        options: Optional[dict[str, RequestOption]] = None,
+    ) -> list[BaseMiddleware]:
+        """Return the full middleware list (Kiota defaults + Autodesk custom).
+
+        Args:
+            options: Optional dict of request options.
+
+        Returns:
+            Ordered list of middleware handlers.
+        """
+        rate_limit_option = RateLimitingHandlerOption()
+        query_param_option = QueryParameterHandlerOption()
+        error_option = ErrorHandlerOption()
+
+        if options:
+            opt = options.get(RateLimitingHandlerOption.get_key())
+            if isinstance(opt, RateLimitingHandlerOption):
+                rate_limit_option = opt
+
+            opt = options.get(QueryParameterHandlerOption.get_key())
+            if isinstance(opt, QueryParameterHandlerOption):
+                query_param_option = opt
+
+            opt = options.get(ErrorHandlerOption.get_key())
+            if isinstance(opt, ErrorHandlerOption):
+                error_option = opt
+
+        middleware = KiotaClientFactory.get_default_middleware(options)
+        middleware.extend([
+            RateLimitingHandler(rate_limit_option),
+            QueryParameterHandler(query_param_option),
+            ErrorHandler(error_option),
+        ])
+        return middleware

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/middleware/__init__.py

@@ -0,0 +1,7 @@
+"""Custom Kiota middleware for Autodesk Platform Services."""
+
+from autodesk_common_httpclient.middleware.error_handler import ErrorContext, ErrorHandler
+from autodesk_common_httpclient.middleware.query_parameter_handler import QueryParameterHandler
+from autodesk_common_httpclient.middleware.rate_limiting_handler import RateLimitingHandler
+
+__all__ = ["ErrorContext", "ErrorHandler", "QueryParameterHandler", "RateLimitingHandler"]

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/middleware/error_handler.py

@@ -0,0 +1,89 @@
+"""Middleware that raises on non-success HTTP responses.
+
+Python equivalent of the C# ``Autodesk.Common.HttpClientLibrary.Middleware.ErrorHandler``.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+import httpx
+from kiota_http.middleware.middleware import BaseMiddleware
+
+from autodesk_common_httpclient.middleware.options.error_handler_option import ErrorHandlerOption
+
+
+@dataclass
+class ErrorContext:
+    """Contains context information about a failed HTTP request."""
+
+    request_url: Optional[str] = None
+    request_method: Optional[str] = None
+    request_headers: dict[str, str] = field(default_factory=dict)
+    request_content: Optional[bytes] = None
+    response_headers: dict[str, str] = field(default_factory=dict)
+    response_content: Optional[bytes] = None
+
+
+class ErrorHandler(BaseMiddleware):
+    """Raises an :class:`httpx.HTTPStatusError` when the response status is not successful.
+
+    The error includes an :class:`ErrorContext` attached via the ``context`` attribute
+    on the exception, containing the full request/response details for debugging.
+    This mirrors the C# ``ErrorHandler`` which throws ``HttpRequestException``
+    with the response attached in ``Data["context"]``.
+
+    Args:
+        options: Configuration controlling whether the handler is active.
+    """
+
+    def __init__(self, options: ErrorHandlerOption | None = None) -> None:
+        super().__init__()
+        self.options = options or ErrorHandlerOption(enabled=True)
+
+    async def send(
+        self, request: httpx.Request, transport: httpx.AsyncBaseTransport
+    ) -> httpx.Response:
+        """Send the request, raising on non-2xx responses if enabled."""
+        # Buffer the request content before sending so it's available in the
+        # error context even after the request completes
+        request_content = request.content if request.content else None
+
+        response = await super().send(request, transport)
+
+        current_options = self._get_current_options(request)
+
+        if current_options.enabled and response.status_code >= 400:
+            # Read/buffer the response body so it remains readable after the
+            # exception propagates
+            response_body = response.text
+            response_content = response.content
+
+            error_context = ErrorContext(
+                request_url=str(request.url),
+                request_method=request.method,
+                request_headers=dict(request.headers),
+                request_content=request_content,
+                response_headers=dict(response.headers),
+                response_content=response_content,
+            )
+
+            error = httpx.HTTPStatusError(
+                message=(
+                    f"Request to '{request.url}' failed with status code "
+                    f"'{response.status_code}'. Response body: {response_body}"
+                ),
+                request=request,
+                response=response,
+            )
+            error.context = error_context  # type: ignore[attr-defined]
+            raise error
+
+        return response
+
+    def _get_current_options(self, request: httpx.Request) -> ErrorHandlerOption:
+        """Return per-request options if set, otherwise fall back to defaults."""
+        request_options = getattr(request, "options", None)
+        if request_options:
+            return request_options.get(ErrorHandlerOption.get_key(), self.options)
+        return self.options

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/middleware/options/__init__.py

@@ -0,0 +1,11 @@
+"""Middleware option classes for custom Autodesk handlers."""
+
+from autodesk_common_httpclient.middleware.options.error_handler_option import ErrorHandlerOption
+from autodesk_common_httpclient.middleware.options.query_parameter_handler_option import (
+    QueryParameterHandlerOption,
+)
+from autodesk_common_httpclient.middleware.options.rate_limiting_handler_option import (
+    RateLimitingHandlerOption,
+)
+
+__all__ = ["ErrorHandlerOption", "QueryParameterHandlerOption", "RateLimitingHandlerOption"]

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/middleware/options/error_handler_option.py

@@ -0,0 +1,19 @@
+"""Option class for the ErrorHandler middleware."""
+from kiota_abstractions.request_option import RequestOption
+
+
+class ErrorHandlerOption(RequestOption):
+    """Configuration for the :class:`~autodesk_common_httpclient.middleware.ErrorHandler`.
+
+    Attributes:
+        enabled: If ``True``, the handler raises on non-success HTTP responses.
+    """
+
+    ERROR_HANDLER_OPTION_KEY = "ErrorHandlerOption"
+
+    def __init__(self, enabled: bool = True) -> None:
+        self.enabled = enabled
+
+    @staticmethod
+    def get_key() -> str:
+        return ErrorHandlerOption.ERROR_HANDLER_OPTION_KEY

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/middleware/options/query_parameter_handler_option.py

@@ -0,0 +1,20 @@
+"""Option class for the QueryParameterHandler middleware."""
+from kiota_abstractions.request_option import RequestOption
+
+
+class QueryParameterHandlerOption(RequestOption):
+    """Configuration for the :class:`~autodesk_common_httpclient.middleware.QueryParameterHandler`.
+
+    Attributes:
+        query_parameters: A dict of query parameter key-value pairs to append
+            or overwrite on every outgoing request.
+    """
+
+    QUERY_PARAMETER_HANDLER_OPTION_KEY = "QueryParameterHandlerOption"
+
+    def __init__(self, query_parameters: dict[str, str] | None = None) -> None:
+        self.query_parameters: dict[str, str] = query_parameters or {}
+
+    @staticmethod
+    def get_key() -> str:
+        return QueryParameterHandlerOption.QUERY_PARAMETER_HANDLER_OPTION_KEY

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/middleware/options/rate_limiting_handler_option.py

@@ -0,0 +1,55 @@
+"""Option class for the RateLimitingHandler middleware."""
+from __future__ import annotations
+
+from kiota_abstractions.request_option import RequestOption
+
+
+class RateLimitingHandlerOption(RequestOption):
+    """Configuration for the :class:`~autodesk_common_httpclient.middleware.RateLimitingHandler`.
+
+    Disabled by default. Call :meth:`set_rate_limit` to enable.
+    """
+
+    RATE_LIMITING_HANDLER_OPTION_KEY = "RateLimitingHandlerOption"
+
+    def __init__(self) -> None:
+        self._max_requests: int = 0
+        self._time_window_seconds: float = 0.0
+
+    def set_rate_limit(self, max_requests: int, time_window_seconds: float) -> None:
+        """Enable rate limiting.
+
+        Args:
+            max_requests: Maximum number of requests allowed within the time window.
+                Must be greater than zero.
+            time_window_seconds: Duration of the sliding window in seconds.
+                Must be greater than zero.
+
+        Raises:
+            ValueError: If either argument is not positive.
+        """
+        if max_requests <= 0:
+            raise ValueError("max_requests must be greater than zero.")
+        if time_window_seconds <= 0:
+            raise ValueError("time_window_seconds must be greater than zero.")
+        self._max_requests = max_requests
+        self._time_window_seconds = time_window_seconds
+
+    def get_rate_limit(self) -> tuple[int, float] | None:
+        """Return the current rate limit, or ``None`` if disabled.
+
+        Returns:
+            A ``(max_requests, time_window_seconds)`` tuple, or ``None``.
+        """
+        if self._max_requests == 0 or self._time_window_seconds == 0.0:
+            return None
+        return (self._max_requests, self._time_window_seconds)
+
+    def disable(self) -> None:
+        """Disable rate limiting."""
+        self._max_requests = 0
+        self._time_window_seconds = 0.0
+
+    @staticmethod
+    def get_key() -> str:
+        return RateLimitingHandlerOption.RATE_LIMITING_HANDLER_OPTION_KEY

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/middleware/query_parameter_handler.py

@@ -0,0 +1,64 @@
+"""Middleware that appends or overwrites query parameters on outgoing requests.
+
+Python equivalent of the C# ``Autodesk.Common.HttpClientLibrary.Middleware.QueryParameterHandler``.
+"""
+from __future__ import annotations
+
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+
+import httpx
+from kiota_http.middleware.middleware import BaseMiddleware
+
+from autodesk_common_httpclient.middleware.options.query_parameter_handler_option import (
+    QueryParameterHandlerOption,
+)
+
+
+class QueryParameterHandler(BaseMiddleware):
+    """Injects additional query parameters into every outgoing request URL.
+
+    Useful for injecting common parameters like API versions, region codes,
+    or tracking identifiers across all API calls.
+
+    Args:
+        options: Configuration containing the query parameters to inject.
+    """
+
+    def __init__(self, options: QueryParameterHandlerOption | None = None) -> None:
+        super().__init__()
+        self.options = options or QueryParameterHandlerOption()
+
+    async def send(
+        self, request: httpx.Request, transport: httpx.AsyncBaseTransport
+    ) -> httpx.Response:
+        """Merge configured query parameters into the request URL, then forward."""
+        current_options = self._get_current_options(request)
+
+        if current_options.query_parameters:
+            parsed = urlparse(str(request.url))
+            # Parse existing query string (keep values as flat strings)
+            existing_params = parse_qs(parsed.query, keep_blank_values=True)
+            # Overwrite / add new parameters
+            for key, value in current_options.query_parameters.items():
+                existing_params[key] = [value]
+            new_query = urlencode(existing_params, doseq=True)
+            new_url = urlunparse(parsed._replace(query=new_query))
+            request = httpx.Request(
+                method=request.method,
+                url=new_url,
+                headers=request.headers,
+                content=request.content,
+                extensions=request.extensions,
+            )
+            # Preserve options attribute if present
+            if hasattr(request, "options"):
+                pass  # httpx.Request is immutable; options are already on the original
+
+        return await super().send(request, transport)
+
+    def _get_current_options(self, request: httpx.Request) -> QueryParameterHandlerOption:
+        """Return per-request options if set, otherwise fall back to defaults."""
+        request_options = getattr(request, "options", None)
+        if request_options:
+            return request_options.get(QueryParameterHandlerOption.get_key(), self.options)
+        return self.options

adsk_platform_httpclient-0.2.9/src/autodesk_common_httpclient/middleware/rate_limiting_handler.py

@@ -0,0 +1,89 @@
+"""Middleware that limits concurrent requests per endpoint using a sliding window.
+
+Python equivalent of the C# ``Autodesk.Common.HttpClientLibrary.Middleware.RateLimitingHandler``.
+"""
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timezone
+
+import httpx
+from kiota_http.middleware.middleware import BaseMiddleware
+
+from autodesk_common_httpclient.middleware.options.rate_limiting_handler_option import (
+    RateLimitingHandlerOption,
+)
+
+
+class _RateLimiter:
+    """Per-endpoint sliding-window rate limiter (async-safe)."""
+
+    def __init__(self, max_requests: int, time_window_seconds: float) -> None:
+        self._max_requests = max_requests
+        self._time_window_seconds = time_window_seconds
+        self._request_count = 0
+        self._reset_time = datetime.now(timezone.utc).timestamp() + time_window_seconds
+        self._lock = asyncio.Lock()
+
+    async def wait_for_availability(self) -> None:
+        """Block until a request slot becomes available in the current window."""
+        async with self._lock:
+            now = datetime.now(timezone.utc).timestamp()
+
+            if now >= self._reset_time:
+                self._request_count = 0
+                self._reset_time = now + self._time_window_seconds
+
+            if self._request_count >= self._max_requests:
+                delay = self._reset_time - now
+                if delay > 0:
+                    await asyncio.sleep(delay)
+                self._request_count = 0
+                self._reset_time = datetime.now(timezone.utc).timestamp() + self._time_window_seconds
+
+            self._request_count += 1
+
+
+class RateLimitingHandler(BaseMiddleware):
+    """Limits the number of concurrent requests per endpoint within a time window.
+
+    Endpoints are identified by ``METHOD|path`` (query string excluded) to avoid
+    counting different query parameter combinations as separate endpoints.
+
+    Args:
+        options: Rate limiting configuration. Disabled by default.
+    """
+
+    def __init__(self, options: RateLimitingHandlerOption | None = None) -> None:
+        super().__init__()
+        self.options = options or RateLimitingHandlerOption()
+        self._rate_limiters: dict[str, _RateLimiter] = {}
+
+    async def send(
+        self, request: httpx.Request, transport: httpx.AsyncBaseTransport
+    ) -> httpx.Response:
+        """Wait for an available rate-limit slot, then forward the request."""
+        current_options = self._get_current_options(request)
+        rate_limit = current_options.get_rate_limit()
+
+        if rate_limit is not None:
+            max_requests, time_window_seconds = rate_limit
+            endpoint = self._get_endpoint(request)
+            if endpoint not in self._rate_limiters:
+                self._rate_limiters[endpoint] = _RateLimiter(max_requests, time_window_seconds)
+            await self._rate_limiters[endpoint].wait_for_availability()
+
+        return await super().send(request, transport)
+
+    @staticmethod
+    def _get_endpoint(request: httpx.Request) -> str:
+        """Derive a stable endpoint key from the request (method + path, no query)."""
+        url = request.url
+        return f"{request.method}|{url.scheme}://{url.host}{url.path}"
+
+    def _get_current_options(self, request: httpx.Request) -> RateLimitingHandlerOption:
+        """Return per-request options if set, otherwise fall back to defaults."""
+        request_options = getattr(request, "options", None)
+        if request_options:
+            return request_options.get(RateLimitingHandlerOption.get_key(), self.options)
+        return self.options