unique_toolkit 1.8.1__tar.gz → 1.9.0__tar.gz

{unique_toolkit-1.8.1 → unique_toolkit-1.9.0}/CHANGELOG.md

@@ -5,6 +5,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.0] - 2026-10-04
+- Define the RequestContext and add aihttp/httpx requestors
+
 ## [1.8.1] - 2026-10-03
 - Fix bug where sub agent evaluation config variable `include_evaluation` did not include aliases for previous names.
 

{unique_toolkit-1.8.1 → unique_toolkit-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.8.1
+Version: 1.9.0
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -118,6 +118,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.0] - 2026-10-04
+- Define the RequestContext and add aihttp/httpx requestors
+
 ## [1.8.1] - 2026-10-03
 - Fix bug where sub agent evaluation config variable `include_evaluation` did not include aliases for previous names.
 

{unique_toolkit-1.8.1 → unique_toolkit-1.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "1.8.1"
+version = "1.9.0"
 description = ""
 authors = [
     "Cedric Klinkert <cedric.klinkert@unique.ch>",
@@ -62,6 +62,7 @@ entangled-cli = "^2.1.13"
 mkdocs-entangled-plugin = "^0.4.0"
 isort = "^6.0.1"
 mkdocs-codeinclude-plugin = "^0.2.1"
+aiohttp = "^3.12.15"
 
 [build-system]
 requires = ["poetry-core"]

{unique_toolkit-1.8.1 → unique_toolkit-1.9.0}/unique_toolkit/_common/api_calling/human_verification_manager.py

@@ -15,6 +15,7 @@ from unique_toolkit._common.endpoint_builder import (
     ResponseType,
 )
 from unique_toolkit._common.endpoint_requestor import (
+    RequestContext,
     RequestorType,
     build_requestor,
 )
@@ -163,7 +164,7 @@ class HumanVerificationManagerForApiCalling(
     def call_api(
         self,
         *,
-        headers: dict[str, str],
+        context: RequestContext,
         path_params: PathParamsType,
         payload: PayloadType,
     ) -> ResponseType:
@@ -171,7 +172,7 @@ class HumanVerificationManagerForApiCalling(
         params.update(payload.model_dump())
 
         response = self._requestor.request(
-            headers=headers,
+            context=context,
             **params,
         )
         return self._operation.handle_response(response)

unique_toolkit-1.9.0/unique_toolkit/_common/endpoint_requestor.py

@@ -0,0 +1,395 @@
+from enum import StrEnum
+from typing import Any, Callable, Generic, Protocol, TypeVar
+from urllib.parse import urljoin, urlparse
+
+from pydantic import BaseModel
+from typing_extensions import ParamSpec
+
+from unique_toolkit._common.endpoint_builder import (
+    ApiOperationProtocol,
+    HttpMethods,
+    PathParamsSpec,
+    PathParamsType,
+    PayloadParamSpec,
+    PayloadType,
+    ResponseType,
+)
+
+# Paramspecs
+CombinedParamsSpec = ParamSpec("CombinedParamsSpec")
+
+# Type variables
+CombinedParamsType = TypeVar("CombinedParamsType", bound=BaseModel)
+
+
+ResponseT_co = TypeVar("ResponseT_co", bound=BaseModel, covariant=True)
+
+
+def _construct_full_url(base_url: str, url: str) -> str:
+    """
+    Construct full URL from base_url and url.
+    If base_url is provided and url is absolute, strip the scheme/netloc from url.
+    """
+    if not base_url:
+        return url
+
+    parsed = urlparse(url)
+    if parsed.scheme:
+        # URL is absolute, extract only path + query + fragment
+        url = parsed._replace(scheme="", netloc="").geturl()
+
+    return urljoin(base_url, url)
+
+
+class RequestContext(BaseModel):
+    base_url: str = ""
+    headers: dict[str, str] | None = None
+
+
+class EndpointRequestorProtocol(Protocol, Generic[CombinedParamsSpec, ResponseT_co]):
+    @classmethod
+    def request(
+        cls,
+        context: RequestContext,
+        *args: CombinedParamsSpec.args,
+        **kwargs: CombinedParamsSpec.kwargs,
+    ) -> ResponseT_co: ...
+
+    @classmethod
+    async def request_async(
+        cls,
+        context: RequestContext,
+        *args: CombinedParamsSpec.args,
+        **kwargs: CombinedParamsSpec.kwargs,
+    ) -> ResponseT_co: ...
+
+
+def build_fake_requestor(
+    operation_type: type[
+        ApiOperationProtocol[
+            PathParamsSpec,
+            PathParamsType,
+            PayloadParamSpec,
+            PayloadType,
+            ResponseType,
+        ]
+    ],
+    combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
+    return_value: dict[str, Any],
+) -> type[EndpointRequestorProtocol[CombinedParamsSpec, ResponseType]]:
+    class FakeRequestor(EndpointRequestorProtocol):
+        _operation = operation_type
+
+        @classmethod
+        def request(
+            cls,
+            context: RequestContext,
+            *args: CombinedParamsSpec.args,
+            **kwargs: CombinedParamsSpec.kwargs,
+        ) -> ResponseType:
+            try:
+                path_params, payload_model = cls._operation.models_from_combined(
+                    combined=kwargs
+                )
+            except Exception as e:
+                raise ValueError(
+                    f"Invalid parameters passed to combined model {combined_model.__name__}: {e}"
+                )
+
+            return cls._operation.handle_response(return_value)
+
+        @classmethod
+        async def request_async(
+            cls,
+            context: RequestContext,
+            headers: dict[str, str] | None = None,
+            *args: CombinedParamsSpec.args,
+            **kwargs: CombinedParamsSpec.kwargs,
+        ) -> ResponseType:
+            raise NotImplementedError(
+                "Async request not implemented for fake requestor"
+            )
+
+    return FakeRequestor
+
+
+def build_request_requestor(
+    operation_type: type[
+        ApiOperationProtocol[
+            PathParamsSpec,
+            PathParamsType,
+            PayloadParamSpec,
+            PayloadType,
+            ResponseType,
+        ]
+    ],
+    combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
+) -> type[EndpointRequestorProtocol[CombinedParamsSpec, ResponseType]]:
+    import requests
+
+    class RequestRequestor(EndpointRequestorProtocol):
+        _operation = operation_type
+
+        @classmethod
+        def request(
+            cls,
+            context: RequestContext,
+            *args: CombinedParamsSpec.args,
+            **kwargs: CombinedParamsSpec.kwargs,
+        ) -> ResponseType:
+            # Create separate instances for path params and payload using endpoint helper
+            path_params, payload_model = cls._operation.models_from_combined(
+                combined=kwargs
+            )
+
+            url = cls._operation.create_url_from_model(path_params)
+            payload = cls._operation.create_payload_from_model(payload_model)
+
+            response = requests.request(
+                method=cls._operation.request_method(),
+                url=_construct_full_url(context.base_url, url),
+                headers=context.headers,
+                json=payload,
+            )
+            return cls._operation.handle_response(response.json())
+
+        @classmethod
+        async def request_async(
+            cls,
+            base_url: str = "",
+            headers: dict[str, str] | None = None,
+            *args: CombinedParamsSpec.args,
+            **kwargs: CombinedParamsSpec.kwargs,
+        ) -> ResponseType:
+            raise NotImplementedError(
+                "Async request not implemented for request requestor"
+            )
+
+    return RequestRequestor
+
+
+def build_httpx_requestor(
+    operation_type: type[
+        ApiOperationProtocol[
+            PathParamsSpec,
+            PathParamsType,
+            PayloadParamSpec,
+            PayloadType,
+            ResponseType,
+        ]
+    ],
+    combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
+) -> type[EndpointRequestorProtocol[CombinedParamsSpec, ResponseType]]:
+    import httpx
+
+    class HttpxRequestor(EndpointRequestorProtocol):
+        _operation = operation_type
+
+        @classmethod
+        def request(
+            cls,
+            context: RequestContext,
+            *args: CombinedParamsSpec.args,
+            **kwargs: CombinedParamsSpec.kwargs,
+        ) -> ResponseType:
+            headers = context.headers or {}
+
+            path_params, payload_model = cls._operation.models_from_combined(
+                combined=kwargs
+            )
+
+            with httpx.Client() as client:
+                response = client.request(
+                    method=cls._operation.request_method(),
+                    url=_construct_full_url(
+                        base_url=context.base_url,
+                        url=cls._operation.create_url_from_model(path_params),
+                    ),
+                    headers=headers,
+                    json=cls._operation.create_payload_from_model(payload_model),
+                )
+                return cls._operation.handle_response(response.json())
+
+        @classmethod
+        async def request_async(
+            cls,
+            context: RequestContext,
+            *args: CombinedParamsSpec.args,
+            **kwargs: CombinedParamsSpec.kwargs,
+        ) -> ResponseType:
+            headers = context.headers or {}
+
+            path_params, payload_model = cls._operation.models_from_combined(
+                combined=kwargs
+            )
+
+            async with httpx.AsyncClient() as client:
+                response = await client.request(
+                    method=cls._operation.request_method(),
+                    url=_construct_full_url(
+                        base_url=context.base_url,
+                        url=cls._operation.create_url_from_model(path_params),
+                    ),
+                    headers=headers,
+                    json=cls._operation.create_payload_from_model(payload_model),
+                )
+                return cls._operation.handle_response(response.json())
+
+    return HttpxRequestor
+
+
+def build_aiohttp_requestor(
+    operation_type: type[
+        ApiOperationProtocol[
+            PathParamsSpec,
+            PathParamsType,
+            PayloadParamSpec,
+            PayloadType,
+            ResponseType,
+        ]
+    ],
+    combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
+) -> type[EndpointRequestorProtocol[CombinedParamsSpec, ResponseType]]:
+    import aiohttp
+
+    class AiohttpRequestor(EndpointRequestorProtocol):
+        _operation = operation_type
+
+        @classmethod
+        def request(
+            cls,
+            context: RequestContext,
+            *args: CombinedParamsSpec.args,
+            **kwargs: CombinedParamsSpec.kwargs,
+        ) -> ResponseType:
+            raise NotImplementedError(
+                "Sync request not implemented for aiohttp requestor"
+            )
+
+        @classmethod
+        async def request_async(
+            cls,
+            context: RequestContext,
+            headers: dict[str, str] | None = None,
+            *args: CombinedParamsSpec.args,
+            **kwargs: CombinedParamsSpec.kwargs,
+        ) -> ResponseType:
+            headers = context.headers or {}
+
+            path_params, payload_model = cls._operation.models_from_combined(
+                combined=kwargs
+            )
+
+            async with aiohttp.ClientSession() as session:
+                response = await session.request(
+                    method=cls._operation.request_method(),
+                    url=_construct_full_url(
+                        base_url=context.base_url,
+                        url=cls._operation.create_url_from_model(path_params),
+                    ),
+                    headers=headers,
+                    json=cls._operation.create_payload_from_model(payload_model),
+                )
+            return cls._operation.handle_response(await response.json())
+
+    return AiohttpRequestor
+
+
+class RequestorType(StrEnum):
+    REQUESTS = "requests"
+    FAKE = "fake"
+    HTTPIX = "httpx"
+    AIOHTTP = "aiohttp"
+
+
+def build_requestor(
+    requestor_type: RequestorType,
+    operation_type: type[
+        ApiOperationProtocol[
+            PathParamsSpec,
+            PathParamsType,
+            PayloadParamSpec,
+            PayloadType,
+            ResponseType,
+        ]
+    ],
+    combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
+    return_value: dict[str, Any] | None = None,
+    **kwargs: Any,
+) -> type[EndpointRequestorProtocol]:
+    match requestor_type:
+        case RequestorType.REQUESTS:
+            return build_request_requestor(
+                operation_type=operation_type, combined_model=combined_model
+            )
+        case RequestorType.FAKE:
+            if return_value is None:
+                raise ValueError("return_value is required for fake requestor")
+            return build_fake_requestor(
+                operation_type=operation_type,
+                combined_model=combined_model,
+                return_value=return_value,
+            )
+        case RequestorType.HTTPIX:
+            return build_httpx_requestor(
+                operation_type=operation_type, combined_model=combined_model
+            )
+        case RequestorType.AIOHTTP:
+            return build_aiohttp_requestor(
+                operation_type=operation_type, combined_model=combined_model
+            )
+
+
+if __name__ == "__main__":
+    from string import Template
+
+    from unique_toolkit._common.endpoint_builder import build_api_operation
+
+    class GetUserPathParams(BaseModel):
+        user_id: int
+
+    class GetUserRequestBody(BaseModel):
+        include_profile: bool = False
+
+    class UserResponse(BaseModel):
+        id: int
+        name: str
+
+    class CombinedParams(GetUserPathParams, GetUserRequestBody):
+        pass
+
+    UserEndpoint = build_api_operation(
+        method=HttpMethods.GET,
+        url_template=Template("https://api.example.com/users/{user_id}"),
+        path_params_constructor=GetUserPathParams,
+        payload_constructor=GetUserRequestBody,
+        response_model_type=UserResponse,
+    )
+
+    FakeUserRequestor = build_fake_requestor(
+        operation_type=UserEndpoint,
+        combined_model=CombinedParams,
+        return_value={"id": 100, "name": "John Doe"},
+    )
+
+    # Note that the return value is a pydantic UserResponse object
+    response = FakeUserRequestor().request(
+        context=RequestContext(headers={"a": "b"}),
+        user_id=123,
+        include_profile=True,
+    )
+
+    RequestRequestor = build_request_requestor(
+        operation_type=UserEndpoint,
+        combined_model=CombinedParams,
+    )
+
+    # Check type hints
+    response = RequestRequestor().request(
+        context=RequestContext(headers={"a": "b"}), user_id=123, include_profile=True
+    )
+
+    print(response.model_dump())
+    print(response.model_json_schema())
+    print(response.id)
+    print(response.name)

unique_toolkit-1.8.1/unique_toolkit/_common/endpoint_requestor.py

@@ -1,204 +0,0 @@
-from enum import StrEnum
-from typing import Any, Callable, Generic, Protocol, TypeVar
-
-from pydantic import BaseModel
-from typing_extensions import ParamSpec
-
-from unique_toolkit._common.endpoint_builder import (
-    ApiOperationProtocol,
-    HttpMethods,
-    PathParamsSpec,
-    PathParamsType,
-    PayloadParamSpec,
-    PayloadType,
-    ResponseType,
-)
-
-# Paramspecs
-CombinedParamsSpec = ParamSpec("CombinedParamsSpec")
-
-# Type variables
-CombinedParamsType = TypeVar("CombinedParamsType", bound=BaseModel)
-
-
-ResponseT_co = TypeVar("ResponseT_co", bound=BaseModel, covariant=True)
-
-
-class EndpointRequestorProtocol(Protocol, Generic[CombinedParamsSpec, ResponseT_co]):
-    @classmethod
-    def request(
-        cls,
-        headers: dict[str, str],
-        *args: CombinedParamsSpec.args,
-        **kwargs: CombinedParamsSpec.kwargs,
-    ) -> ResponseT_co: ...
-
-
-def build_fake_requestor(
-    operation_type: type[
-        ApiOperationProtocol[
-            PathParamsSpec,
-            PathParamsType,
-            PayloadParamSpec,
-            PayloadType,
-            ResponseType,
-        ]
-    ],
-    combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
-    return_value: dict[str, Any],
-) -> type[EndpointRequestorProtocol[CombinedParamsSpec, ResponseType]]:
-    class FakeRequestor(EndpointRequestorProtocol):
-        _operation = operation_type
-
-        @classmethod
-        def request(
-            cls,
-            headers: dict[str, str],
-            *args: CombinedParamsSpec.args,
-            **kwargs: CombinedParamsSpec.kwargs,
-        ) -> ResponseType:
-            try:
-                path_params, payload_model = cls._operation.models_from_combined(
-                    combined=kwargs
-                )
-            except Exception as e:
-                raise ValueError(
-                    f"Invalid parameters passed to combined model {combined_model.__name__}: {e}"
-                )
-
-            return cls._operation.handle_response(return_value)
-
-    return FakeRequestor
-
-
-def build_request_requestor(
-    operation_type: type[
-        ApiOperationProtocol[
-            PathParamsSpec,
-            PathParamsType,
-            PayloadParamSpec,
-            PayloadType,
-            ResponseType,
-        ]
-    ],
-    combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
-) -> type[EndpointRequestorProtocol[CombinedParamsSpec, ResponseType]]:
-    import requests
-
-    class RequestRequestor(EndpointRequestorProtocol):
-        _operation = operation_type
-
-        @classmethod
-        def request(
-            cls,
-            headers: dict[str, str],
-            *args: CombinedParamsSpec.args,
-            **kwargs: CombinedParamsSpec.kwargs,
-        ) -> ResponseType:
-            # Create separate instances for path params and payload using endpoint helper
-            path_params, payload_model = cls._operation.models_from_combined(
-                combined=kwargs
-            )
-
-            url = cls._operation.create_url_from_model(path_params)
-            payload = cls._operation.create_payload_from_model(payload_model)
-
-            response = requests.request(
-                method=cls._operation.request_method(),
-                url=url,
-                headers=headers,
-                json=payload,
-            )
-            return cls._operation.handle_response(response.json())
-
-    return RequestRequestor
-
-
-class RequestorType(StrEnum):
-    REQUESTS = "requests"
-    FAKE = "fake"
-
-
-def build_requestor(
-    requestor_type: RequestorType,
-    operation_type: type[
-        ApiOperationProtocol[
-            PathParamsSpec,
-            PathParamsType,
-            PayloadParamSpec,
-            PayloadType,
-            ResponseType,
-        ]
-    ],
-    combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
-    return_value: dict[str, Any] | None = None,
-    **kwargs: Any,
-) -> type[EndpointRequestorProtocol]:
-    match requestor_type:
-        case RequestorType.REQUESTS:
-            return build_request_requestor(
-                operation_type=operation_type, combined_model=combined_model
-            )
-        case RequestorType.FAKE:
-            if return_value is None:
-                raise ValueError("return_value is required for fake requestor")
-            return build_fake_requestor(
-                operation_type=operation_type,
-                combined_model=combined_model,
-                return_value=return_value,
-            )
-
-
-if __name__ == "__main__":
-    from string import Template
-
-    from unique_toolkit._common.endpoint_builder import build_api_operation
-
-    class GetUserPathParams(BaseModel):
-        user_id: int
-
-    class GetUserRequestBody(BaseModel):
-        include_profile: bool = False
-
-    class UserResponse(BaseModel):
-        id: int
-        name: str
-
-    class CombinedParams(GetUserPathParams, GetUserRequestBody):
-        pass
-
-    UserEndpoint = build_api_operation(
-        method=HttpMethods.GET,
-        url_template=Template("https://api.example.com/users/{user_id}"),
-        path_params_constructor=GetUserPathParams,
-        payload_constructor=GetUserRequestBody,
-        response_model_type=UserResponse,
-    )
-
-    FakeUserRequestor = build_fake_requestor(
-        operation_type=UserEndpoint,
-        combined_model=CombinedParams,
-        return_value={"id": 100, "name": "John Doe"},
-    )
-
-    # Note that the return value is a pydantic UserResponse object
-    response = FakeUserRequestor().request(
-        headers={"a": "b"},
-        user_id=123,
-        include_profile=True,
-    )
-
-    RequestRequstor = build_request_requestor(
-        operation_type=UserEndpoint,
-        combined_model=CombinedParams,
-    )
-
-    # Check type hints
-    response = RequestRequstor().request(
-        headers={"a": "b"}, user_id=123, include_profile=True
-    )
-
-    print(response.model_dump())
-    print(response.model_json_schema())
-    print(response.id)
-    print(response.name)