unique_toolkit 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

unique_toolkit/_common/api_calling/human_verification_manager.py

@@ -0,0 +1,250 @@
+import hashlib
+from datetime import datetime
+from logging import Logger
+from typing import Any, Generic
+
+import jinja2
+from pydantic import BaseModel
+
+from unique_toolkit._common.endpoint_builder import (
+    ApiOperationProtocol,
+    PathParamsSpec,
+    PathParamsType,
+    PayloadParamSpec,
+    PayloadType,
+    ResponseType,
+)
+from unique_toolkit._common.endpoint_requestor import (
+    RequestorType,
+    build_requestor,
+)
+from unique_toolkit._common.pydantic_helpers import create_union_model
+from unique_toolkit._common.string_utilities import (
+    dict_to_markdown_table,
+    extract_dicts_from_string,
+)
+from unique_toolkit.chat.schemas import ChatMessage, ChatMessageRole
+
+
+class HumanConfirmation(BaseModel):
+    payload_hash: str
+    time_stamp: datetime
+
+
+NEXT_USER_MESSAGE_JINJA2_TEMPLATE = jinja2.Template("""I confirm the api call with the following data:
+```json
+{{ api_call_as_json }}
+```""")
+
+
+ASSISTANT_CONFIRMATION_MESSAGE_JINJA2_TEMPLATE = jinja2.Template("""I would like to call the api with the following data:
+
+{{ api_call_as_markdown_table }}
+
+[{{ button_text }}](https://prompt={{ next_user_message | urlencode }})""")
+
+
+class HumanVerificationManagerForApiCalling(
+    Generic[
+        PathParamsSpec,
+        PathParamsType,
+        PayloadParamSpec,
+        PayloadType,
+        ResponseType,
+    ]
+):
+    """
+    Manages human verification for api calling.
+
+    The idea is that the manager is able to produce the verification message to the user
+    and to detect an api call from the user message.
+
+    If it detects such a verification message in the user message, it will call the api
+    and incorporate the response into the user message.
+    """
+
+    def __init__(
+        self,
+        *,
+        logger: Logger,
+        operation: type[
+            ApiOperationProtocol[
+                PathParamsSpec,
+                PathParamsType,
+                PayloadParamSpec,
+                PayloadType,
+                ResponseType,
+            ]
+        ],
+        requestor_type: RequestorType = RequestorType.REQUESTS,
+        **kwargs: dict[str, Any],
+    ):
+        self._logger = logger
+        self._operation = operation
+
+        # Create internal models for this manager instance
+
+        class ConcreteApiCall(BaseModel):
+            confirmation: HumanConfirmation
+            payload: self._operation.payload_model()  # type: ignore
+
+        self._api_call_model = ConcreteApiCall
+
+        self._combined_params_model = create_union_model(
+            model_type_a=self._operation.path_params_model(),
+            model_type_b=self._operation.payload_model(),
+        )
+        self._requestor_type = requestor_type
+        self._requestor = build_requestor(
+            requestor_type=requestor_type,
+            operation_type=operation,
+            combined_model=self._combined_params_model,
+            **kwargs,
+        )
+
+    def detect_api_calls_from_user_message(
+        self, *, last_assistant_message: ChatMessage, user_message: str
+    ) -> PayloadType | None:
+        user_message_dicts = extract_dicts_from_string(user_message)
+        if len(user_message_dicts) == 0:
+            return None
+
+        user_message_dicts.reverse()
+        for user_message_dict in user_message_dicts:
+            try:
+                # Convert dict to payload model first, then create payload
+                api_call = self._api_call_model.model_validate(
+                    user_message_dict, by_alias=True, by_name=True
+                )
+                if self._verify_human_verification(
+                    api_call.confirmation, last_assistant_message
+                ):
+                    return api_call.payload
+            except Exception as e:
+                self._logger.error(f"Error detecting api calls from user message: {e}")
+
+        return None
+
+    def _verify_human_verification(
+        self, confirmation: HumanConfirmation, last_assistant_message: ChatMessage
+    ) -> bool:
+        if (
+            last_assistant_message.role != ChatMessageRole.ASSISTANT
+            or last_assistant_message.content is None
+        ):
+            self._logger.error(
+                "Last assistant message is not an assistant message or content is empty."
+            )
+            return False
+
+        return confirmation.payload_hash in last_assistant_message.content
+
+    def _create_next_user_message(self, payload: PayloadType) -> str:
+        api_call = self._api_call_model(
+            payload=payload,
+            confirmation=HumanConfirmation(
+                payload_hash=hashlib.sha256(
+                    payload.model_dump_json().encode()
+                ).hexdigest(),
+                time_stamp=datetime.now(),
+            ),
+        )
+        return NEXT_USER_MESSAGE_JINJA2_TEMPLATE.render(
+            api_call_as_json=api_call.model_dump_json(indent=2)
+        )
+
+    def create_assistant_confirmation_message(self, *, payload: PayloadType) -> str:
+        return ASSISTANT_CONFIRMATION_MESSAGE_JINJA2_TEMPLATE.render(
+            api_call_as_markdown_table=dict_to_markdown_table(payload.model_dump()),
+            button_text="Please confirm the call by pressing this button.",
+            next_user_message=self._create_next_user_message(payload),
+        )
+
+    def call_api(
+        self,
+        *,
+        headers: dict[str, str],
+        path_params: PathParamsType,
+        payload: PayloadType,
+    ) -> ResponseType:
+        params = path_params.model_dump()
+        params.update(payload.model_dump())
+
+        response = self._requestor.request(
+            headers=headers,
+            **params,
+        )
+        return self._operation.handle_response(response)
+
+
+if __name__ == "__main__":
+    import logging
+    from string import Template
+
+    from unique_toolkit._common.endpoint_builder import (
+        EndpointMethods,
+        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=EndpointMethods.GET,
+        url_template=Template("https://api.example.com/users/{user_id}"),
+        path_params_constructor=GetUserPathParams,
+        payload_constructor=GetUserRequestBody,
+        response_model_type=UserResponse,
+    )
+
+    human_verification_manager = HumanVerificationManagerForApiCalling(
+        logger=logging.getLogger(__name__),
+        operation=UserEndpoint,
+        requestor_type=RequestorType.FAKE,
+        return_value={"id": 100, "name": "John Doe"},
+    )
+
+    payload = GetUserRequestBody(include_profile=True)
+
+    api_call = human_verification_manager._api_call_model(
+        payload=payload,
+        confirmation=HumanConfirmation(
+            payload_hash=hashlib.sha256(payload.model_dump_json().encode()).hexdigest(),
+            time_stamp=datetime.now(),
+        ),
+    )
+
+    last_assistant_message = ChatMessage(
+        role=ChatMessageRole.ASSISTANT,
+        text=api_call.confirmation.payload_hash,
+        chat_id="123",
+    )
+
+    user_message_with_api_call = human_verification_manager._create_next_user_message(
+        payload=payload
+    )
+
+    print(user_message_with_api_call)
+
+    payload = human_verification_manager.detect_api_calls_from_user_message(
+        user_message=user_message_with_api_call,
+        last_assistant_message=last_assistant_message,
+    )
+
+    if payload is None:
+        print("❌ Detection failed - payload is None")
+        exit(1)
+    else:
+        print("✅ Detection successful!")
+        print(f"Payload: {payload.model_dump()}")
+        print("✅ Dict extraction from string works correctly!")

unique_toolkit/_common/endpoint_builder.py

@@ -12,9 +12,11 @@ from typing import (
     ParamSpec,
     Protocol,
     TypeVar,
+    cast,
 )
 
 from pydantic import BaseModel
+from typing_extensions import deprecated
 
 # Paramspecs
 PayloadParamSpec = ParamSpec("PayloadParamSpec")
@@ -31,7 +33,7 @@ PayloadType = TypeVar("PayloadType", bound=BaseModel)
 ModelConstructor = Callable[..., BaseModel]
 
 
-class EndpointMethods(StrEnum):
+class HttpMethods(StrEnum):
     GET = "GET"
     POST = "POST"
     PUT = "PUT"
@@ -41,8 +43,11 @@ class EndpointMethods(StrEnum):
     HEAD = "HEAD"
 
 
-# Necessary for typing of make_endpoint_class
-class EndpointClassProtocol(
+# Backward compatibility TODO: Remove in 2.0.0.
+EndpointMethods = HttpMethods
+
+
+class ApiOperationProtocol(
     Protocol,
     Generic[
         PathParamsSpec,
@@ -52,9 +57,14 @@ class EndpointClassProtocol(
         ResponseType,
     ],
 ):
-    path_params_model: type[PathParamsType]
-    payload_model: type[PayloadType]
-    response_model: type[ResponseType]
+    @staticmethod
+    def path_params_model() -> type[PathParamsType]: ...
+
+    @staticmethod
+    def payload_model() -> type[PayloadType]: ...
+
+    @staticmethod
+    def response_model() -> type[ResponseType]: ...
 
     @staticmethod
     def create_url(
@@ -78,18 +88,23 @@ class EndpointClassProtocol(
     @staticmethod
     def request_method() -> EndpointMethods: ...
 
+    @staticmethod
+    def models_from_combined(
+        combined: dict[str, Any],
+    ) -> tuple[PathParamsType, PayloadType]: ...
+
 
 # Model for any client to implement
-def build_endpoint_class(
+def build_api_operation(
     *,
-    method: EndpointMethods,
+    method: HttpMethods,
     url_template: Template,
     path_params_constructor: Callable[PathParamsSpec, PathParamsType],
     payload_constructor: Callable[PayloadParamSpec, PayloadType],
     response_model_type: type[ResponseType],
     dump_options: dict | None = None,
 ) -> type[
-    EndpointClassProtocol[
+    ApiOperationProtocol[
         PathParamsSpec,
         PathParamsType,
         PayloadParamSpec,
@@ -107,11 +122,6 @@ def build_endpoint_class(
     """
 
     # Verify that the path_params_constructor and payload_constructor are valid pydantic models
-    if not isinstance(path_params_constructor, type(BaseModel)):
-        raise ValueError("path_params_constructor must be a pydantic model")
-    if not isinstance(payload_constructor, type(BaseModel)):
-        raise ValueError("payload_constructor must be a pydantic model")
-
     if not dump_options:
         dump_options = {
             "exclude_unset": True,
@@ -119,10 +129,18 @@ def build_endpoint_class(
             "exclude_defaults": True,
         }
 
-    class EndpointClass(EndpointClassProtocol):
-        path_params_model = path_params_constructor  # type: ignore
-        payload_model = payload_constructor  # type: ignore
-        response_model = response_model_type
+    class Operation(ApiOperationProtocol):
+        @staticmethod
+        def path_params_model() -> type[PathParamsType]:
+            return cast(type[PathParamsType], path_params_constructor)
+
+        @staticmethod
+        def payload_model() -> type[PayloadType]:
+            return cast(type[PayloadType], payload_constructor)
+
+        @staticmethod
+        def response_model() -> type[ResponseType]:
+            return response_model_type
 
         @staticmethod
         def create_url(
@@ -130,7 +148,7 @@ def build_endpoint_class(
             **kwargs: PathParamsSpec.kwargs,
         ) -> str:
             """Create URL from path parameters."""
-            path_model = EndpointClass.path_params_model(*args, **kwargs)
+            path_model = Operation.path_params_model()(*args, **kwargs)
             path_dict = path_model.model_dump(**dump_options)
 
             # Extract expected path parameters from template
@@ -158,7 +176,7 @@ def build_endpoint_class(
             *args: PayloadParamSpec.args, **kwargs: PayloadParamSpec.kwargs
         ) -> dict[str, Any]:
             """Create request body payload."""
-            request_model = EndpointClass.payload_model(*args, **kwargs)
+            request_model = Operation.payload_model()(*args, **kwargs)
             return request_model.model_dump(**dump_options)
 
         @staticmethod
@@ -167,13 +185,58 @@ def build_endpoint_class(
 
         @staticmethod
         def handle_response(response: dict[str, Any]) -> ResponseType:
-            return EndpointClass.response_model.model_validate(response)
+            return Operation.response_model().model_validate(response)
 
         @staticmethod
-        def request_method() -> EndpointMethods:
+        def request_method() -> HttpMethods:
             return method
 
-    return EndpointClass
+        @staticmethod
+        def models_from_combined(
+            combined: dict[str, Any],
+        ) -> tuple[PathParamsType, PayloadType]:
+            path_params = Operation.path_params_model().model_validate(
+                combined, by_alias=True, by_name=True
+            )
+            payload = Operation.payload_model().model_validate(
+                combined, by_alias=True, by_name=True
+            )
+            return path_params, payload
+
+    return Operation
+
+
+@deprecated("Use ApiOperationProtocol instead")
+class EndpointClassProtocol(ApiOperationProtocol):
+    pass
+
+
+@deprecated("Use build_api_operation instead")
+def build_endpoint_class(
+    *,
+    method: HttpMethods,
+    url_template: Template,
+    path_params_constructor: Callable[PathParamsSpec, PathParamsType],
+    payload_constructor: Callable[PayloadParamSpec, PayloadType],
+    response_model_type: type[ResponseType],
+    dump_options: dict | None = None,
+) -> type[
+    ApiOperationProtocol[
+        PathParamsSpec,
+        PathParamsType,
+        PayloadParamSpec,
+        PayloadType,
+        ResponseType,
+    ]
+]:
+    return build_api_operation(
+        method=method,
+        url_template=url_template,
+        path_params_constructor=path_params_constructor,
+        payload_constructor=payload_constructor,
+        response_model_type=response_model_type,
+        dump_options=dump_options,
+    )
 
 
 if __name__ == "__main__":
@@ -195,7 +258,7 @@ if __name__ == "__main__":
         name: str
 
     # Example usage of make_endpoint_class
-    UserEndpoint = build_endpoint_class(
+    UserOperation = build_endpoint_class(
         url_template=Template("/users/${user_id}"),
         path_params_constructor=GetUserPathParams,
         payload_constructor=GetUserRequestBody,
@@ -204,15 +267,15 @@ if __name__ == "__main__":
     )
 
     # Create URL from path parameters
-    url = UserEndpoint.create_url(user_id=123)
+    url = UserOperation.create_url(user_id=123)
     print(f"URL: {url}")
 
     # Create payload from request body parameters
-    payload = UserEndpoint.create_payload(include_profile=True)
+    payload = UserOperation.create_payload(include_profile=True)
     print(f"Payload: {payload}")
 
     # Create response from endpoint
-    response = UserEndpoint.handle_response(
+    response = UserOperation.handle_response(
         {
             "id": 123,
             "name": "John Doe",

unique_toolkit/_common/endpoint_requestor.py

@@ -5,8 +5,8 @@ from pydantic import BaseModel
 from typing_extensions import ParamSpec
 
 from unique_toolkit._common.endpoint_builder import (
-    EndpointClassProtocol,
-    EndpointMethods,
+    ApiOperationProtocol,
+    HttpMethods,
     PathParamsSpec,
     PathParamsType,
     PayloadParamSpec,
@@ -21,19 +21,22 @@ CombinedParamsSpec = ParamSpec("CombinedParamsSpec")
 CombinedParamsType = TypeVar("CombinedParamsType", bound=BaseModel)
 
 
-class EndpointRequestorProtocol(Protocol, Generic[CombinedParamsSpec, ResponseType]):
+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,
-    ) -> ResponseType: ...
+    ) -> ResponseT_co: ...
 
 
 def build_fake_requestor(
-    endpoint_type: type[
-        EndpointClassProtocol[
+    operation_type: type[
+        ApiOperationProtocol[
             PathParamsSpec,
             PathParamsType,
             PayloadParamSpec,
@@ -45,7 +48,7 @@ def build_fake_requestor(
     return_value: dict[str, Any],
 ) -> type[EndpointRequestorProtocol[CombinedParamsSpec, ResponseType]]:
     class FakeRequestor(EndpointRequestorProtocol):
-        _endpoint = endpoint_type
+        _operation = operation_type
 
         @classmethod
         def request(
@@ -55,20 +58,22 @@ def build_fake_requestor(
             **kwargs: CombinedParamsSpec.kwargs,
         ) -> ResponseType:
             try:
-                combined_model(*args, **kwargs)
+                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._endpoint.handle_response(return_value)
+            return cls._operation.handle_response(return_value)
 
     return FakeRequestor
 
 
 def build_request_requestor(
-    endpoint_type: type[
-        EndpointClassProtocol[
+    operation_type: type[
+        ApiOperationProtocol[
             PathParamsSpec,
             PathParamsType,
             PayloadParamSpec,
@@ -77,11 +82,11 @@ def build_request_requestor(
         ]
     ],
     combined_model: Callable[CombinedParamsSpec, CombinedParamsType],
-) -> type[EndpointRequestorProtocol]:
+) -> type[EndpointRequestorProtocol[CombinedParamsSpec, ResponseType]]:
     import requests
 
     class RequestRequestor(EndpointRequestorProtocol):
-        _endpoint = endpoint_type
+        _operation = operation_type
 
         @classmethod
         def request(
@@ -90,18 +95,21 @@ def build_request_requestor(
             *args: CombinedParamsSpec.args,
             **kwargs: CombinedParamsSpec.kwargs,
         ) -> ResponseType:
-            url = cls._endpoint.create_url_from_model(combined_model(*args, **kwargs))
-            payload = cls._endpoint.create_payload_from_model(
-                combined_model(*args, **kwargs)
+            # 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._endpoint.request_method(),
+                method=cls._operation.request_method(),
                 url=url,
                 headers=headers,
                 json=payload,
             )
-            return cls._endpoint.handle_response(response.json())
+            return cls._operation.handle_response(response.json())
 
     return RequestRequestor
 
@@ -113,8 +121,8 @@ class RequestorType(StrEnum):
 
 def build_requestor(
     requestor_type: RequestorType,
-    endpoint_type: type[
-        EndpointClassProtocol[
+    operation_type: type[
+        ApiOperationProtocol[
             PathParamsSpec,
             PathParamsType,
             PayloadParamSpec,
@@ -129,13 +137,13 @@ def build_requestor(
     match requestor_type:
         case RequestorType.REQUESTS:
             return build_request_requestor(
-                endpoint_type=endpoint_type, combined_model=combined_model
+                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(
-                endpoint_type=endpoint_type,
+                operation_type=operation_type,
                 combined_model=combined_model,
                 return_value=return_value,
             )
@@ -144,7 +152,7 @@ def build_requestor(
 if __name__ == "__main__":
     from string import Template
 
-    from unique_toolkit._common.endpoint_builder import build_endpoint_class
+    from unique_toolkit._common.endpoint_builder import build_api_operation
 
     class GetUserPathParams(BaseModel):
         user_id: int
@@ -159,8 +167,8 @@ if __name__ == "__main__":
     class CombinedParams(GetUserPathParams, GetUserRequestBody):
         pass
 
-    UserEndpoint = build_endpoint_class(
-        method=EndpointMethods.GET,
+    UserEndpoint = build_api_operation(
+        method=HttpMethods.GET,
         url_template=Template("https://api.example.com/users/{user_id}"),
         path_params_constructor=GetUserPathParams,
         payload_constructor=GetUserRequestBody,
@@ -168,7 +176,7 @@ if __name__ == "__main__":
     )
 
     FakeUserRequestor = build_fake_requestor(
-        endpoint_type=UserEndpoint,
+        operation_type=UserEndpoint,
         combined_model=CombinedParams,
         return_value={"id": 100, "name": "John Doe"},
     )
@@ -180,6 +188,16 @@ if __name__ == "__main__":
         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)

unique_toolkit/_common/pydantic_helpers.py

@@ -1,7 +1,9 @@
 import logging
+import warnings
+from typing import TypeVar
 
 import humps
-from pydantic import ConfigDict
+from pydantic import BaseModel, ConfigDict, Field, create_model
 from pydantic.fields import ComputedFieldInfo, FieldInfo
 
 logger = logging.getLogger(__name__)
@@ -19,11 +21,133 @@ def model_title_generator(model: type) -> str:
 
 
 def get_configuration_dict(**kwargs) -> ConfigDict:
-    return ConfigDict(
+    config = {
         # alias_generator=to_camel,
-        field_title_generator=field_title_generator,
-        model_title_generator=model_title_generator,
+        "field_title_generator": field_title_generator,
+        "model_title_generator": model_title_generator,
         # populate_by_name=True,
         # protected_namespaces=(),
-        **kwargs,
-    )
+    }
+    config.update(kwargs)
+    return ConfigDict(**config)
+
+
+ModelTypeA = TypeVar("ModelTypeA", bound=BaseModel)
+ModelTypeB = TypeVar("ModelTypeB", bound=BaseModel)
+
+
+def _name_intersection(
+    model_type_a: type[ModelTypeA], model_type_b: type[ModelTypeB]
+) -> set[str]:
+    field_names_a = set(model_type_a.model_fields.keys())
+    field_names_b = set(model_type_b.model_fields.keys())
+    return field_names_a.intersection(field_names_b)
+
+
+def create_union_model(
+    model_type_a: type[ModelTypeA],
+    model_type_b: type[ModelTypeB],
+    model_name: str = "UnionModel",
+    config_dict: ConfigDict = ConfigDict(),
+) -> type[BaseModel]:
+    """
+    Creates a model that is the union of the two input models.
+    Prefers fields from model_type_a.
+    """
+
+    if len(_name_intersection(model_type_a, model_type_b)) > 0:
+        warnings.warn(
+            f"The two input models have common field names: {_name_intersection(model_type_a, model_type_b)}"
+        )
+
+    fields = {}
+    for name, field in model_type_b.model_fields.items():
+        fields[name] = (field.annotation, field)
+    for name, field in model_type_a.model_fields.items():
+        fields[name] = (field.annotation, field)
+
+    CombinedModel = create_model(model_name, __config__=config_dict, **fields)
+    return CombinedModel
+
+
+def create_intersection_model(
+    model_type_a: type[ModelTypeA],
+    model_type_b: type[ModelTypeB],
+    model_name: str = "IntersectionModel",
+    config_dict: ConfigDict = ConfigDict(),
+) -> type[BaseModel]:
+    """
+    Creates a model that is the intersection of the two input models.
+    Prefers fields from model_type_a.
+    """
+
+    if len(_name_intersection(model_type_a, model_type_b)) == 0:
+        warnings.warn(
+            f"The two input models have no common field names: {_name_intersection(model_type_a, model_type_b)}"
+        )
+
+    fields = {}
+    field_names1 = set(model_type_a.model_fields.keys())
+    field_names2 = set(model_type_b.model_fields.keys())
+    common_field_names = field_names1.intersection(field_names2)
+
+    for name in common_field_names:
+        if name in field_names1.intersection(field_names2):
+            fields[name] = (
+                model_type_a.model_fields[name].annotation,
+                model_type_a.model_fields[name],
+            )
+
+    IntersectionModel = create_model(model_name, __config__=config_dict, **fields)
+    return IntersectionModel
+
+
+def create_complement_model(
+    model_type_a: type[ModelTypeA],
+    model_type_b: type[ModelTypeB],
+    model_name: str = "ComplementModel",
+    config_dict: ConfigDict = ConfigDict(),
+) -> type[BaseModel]:
+    """
+    Creates a model that is the complement of the two input models
+    i.e all fields from model_type_a that are not in model_type_b
+    """
+
+    if len(_name_intersection(model_type_a, model_type_b)) == 0:
+        warnings.warn(
+            f"The two input models have no common field names: {_name_intersection(model_type_a, model_type_b)}"
+        )
+
+    fields = {}
+    field_names_a = set(model_type_a.model_fields.keys())
+    field_names_b = set(model_type_b.model_fields.keys())
+    complement_field_names = field_names_a.difference(field_names_b)
+
+    for name in complement_field_names:
+        fields[name] = (
+            model_type_a.model_fields[name].annotation,
+            model_type_a.model_fields[name],
+        )
+
+    ComplementModel = create_model(model_name, __config__=config_dict, **fields)
+
+    return ComplementModel
+
+
+if __name__ == "__main__":
+
+    class ModelType1(BaseModel):
+        field1: int = Field(default=1, description="Field 1")
+        field2: str = Field(
+            default="test",
+            description="Field 2",
+            json_schema_extra={"title": "Field 2"},
+        )
+
+    class ModelType2(BaseModel):
+        field3: float
+        field4: bool
+
+    combined_model = create_union_model(ModelType1, ModelType2)
+
+    print(combined_model.model_fields)

unique_toolkit/_common/string_utilities.py

@@ -0,0 +1,89 @@
+import json
+import re
+from typing import Any
+
+
+def _is_elementary_type(value: Any) -> bool:
+    """Check if a value is an elementary type (str, int, float, bool, None)."""
+    return isinstance(value, (str, int, float, bool, type(None)))
+
+
+def _is_elementary_dict(data: dict[str, Any]) -> bool:
+    """Check if all values in the dictionary are elementary types."""
+    return all(_is_elementary_type(value) for value in data.values())
+
+
+def dict_to_markdown_table(data: dict[str, Any]) -> str:
+    """
+    Convert a dictionary to a markdown table if all values are elementary types,
+    otherwise return stringified JSON.
+
+    Args:
+        data: Dictionary to convert
+
+    Returns:
+        Markdown table string or JSON string
+    """
+    if not isinstance(data, dict):
+        return json.dumps(data, indent=2)
+
+    if not _is_elementary_dict(data):
+        return json.dumps(data, indent=2)
+
+    if not data:  # Empty dict
+        return "| Key | Value |\n|-----|-------|\n| (empty) | (empty) |"
+
+    # Create markdown table
+    table_lines = ["| Key | Value |", "|-----|-------|"]
+
+    for key, value in data.items():
+        # Handle None values
+        if value is None:
+            value_str = "null"
+        # Handle boolean values
+        elif isinstance(value, bool):
+            value_str = "true" if value else "false"
+        # Handle other values
+        else:
+            value_str = str(value)
+
+        # Escape pipe characters in the content
+        key_escaped = str(key).replace("|", "\\|")
+        value_escaped = value_str.replace("|", "\\|")
+
+        table_lines.append(f"| {key_escaped} | {value_escaped} |")
+
+    return "\n".join(table_lines) + "\n"
+
+
+def extract_dicts_from_string(text: str) -> list[dict[str, Any]]:
+    """
+    Extract and parse a JSON dictionary from a string.
+
+    The string should be wrapped in ```json tags. Example:
+
+    ```json
+    {"key": "value"}
+    ```
+
+    Args:
+        text: String that may contain JSON
+
+    Returns:
+        Parsed dictionary or None if no valid JSON found
+    """
+    # Find JSON-like content between ```json and ``` tags
+    pattern = r"```json\s*(\{.*?\})\s*```"
+    matches = re.findall(pattern, text, re.DOTALL)
+
+    dictionaries = []
+    for match in matches:
+        try:
+            # Try to parse as JSON
+            parsed = json.loads(match)
+            if isinstance(parsed, dict):
+                dictionaries.append(parsed)
+        except json.JSONDecodeError:
+            continue
+
+    return dictionaries

unique_toolkit/_common/validators.py

@@ -17,7 +17,14 @@ LMI = Annotated[
     LanguageModelInfo,
     BeforeValidator(
         lambda v: validate_and_init_language_model_info(v),
-        json_schema_input_type=str | LanguageModelName | LanguageModelInfo,
+        json_schema_input_type=LanguageModelName
+        | Annotated[
+            str,
+            Field(
+                title="Language Model String",
+            ),
+        ]
+        | LanguageModelInfo,
     ),
     PlainSerializer(
         lambda v: serialize_lmi(v),

{unique_toolkit-1.1.2.dist-info → unique_toolkit-1.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.1.2
+Version: 1.1.4
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -118,6 +118,13 @@ 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.1.4] - 2025-09-23
+- First version human verification on api calls
+
+## [1.1.3] - 2025-09-23
+- Updated LMI JSON schema input type to include annotated string field with title
+
 ## [1.1.2] - 2025-09-22
 - Fixed bug tool selection for exclusive tools
 

{unique_toolkit-1.1.2.dist-info → unique_toolkit-1.1.4.dist-info}/RECORD

@@ -1,6 +1,7 @@
 unique_toolkit/__init__.py,sha256=nbOYPIKERt-ITsgifrnJhatn1YNR38Ntumw-dCn_tsA,714
 unique_toolkit/_common/_base_service.py,sha256=S8H0rAebx7GsOldA7xInLp3aQJt9yEPDQdsGSFRJsGg,276
 unique_toolkit/_common/_time_utils.py,sha256=ztmTovTvr-3w71Ns2VwXC65OKUUh-sQlzbHdKTQWm-w,135
+unique_toolkit/_common/api_calling/human_verification_manager.py,sha256=UMOkY1cNhJ6JmtiBl3a4mQ3J21uOyKoCbVu7nR3A5eY,7799
 unique_toolkit/_common/base_model_type_attribute.py,sha256=7rzVqjXa0deYEixeo_pJSJcQ7nKXpWK_UGpOiEH3yZY,10382
 unique_toolkit/_common/chunk_relevancy_sorter/config.py,sha256=kDSEcXeIWGvzK4IXT3pBofTXeUnq3a9qRWaPllweR-s,1817
 unique_toolkit/_common/chunk_relevancy_sorter/exception.py,sha256=1mY4zjbvnXsd5oIxwiVsma09bS2XRnHrxW8KJBGtgCM,126
@@ -8,17 +9,18 @@ unique_toolkit/_common/chunk_relevancy_sorter/schemas.py,sha256=YAyvXzVk8h5q6FEs
 unique_toolkit/_common/chunk_relevancy_sorter/service.py,sha256=ZX1pxcy53zh3Ha0_pN6yYIbMX1acRxcvqKTPTKpGKwA,13938
 unique_toolkit/_common/chunk_relevancy_sorter/tests/test_service.py,sha256=UhDllC40Y1OUQvkU6pe3nu6NR7v0d25yldE6FyozuZI,8926
 unique_toolkit/_common/default_language_model.py,sha256=tmHSqg6e8G7RmKqmdE_tmLxkSN0x-aGoyUdy6Pl2oAE,334
-unique_toolkit/_common/endpoint_builder.py,sha256=zZFEeMAHySWh2AU-nuufT7iNd0NT54qA6AAxNEVDZb0,6635
-unique_toolkit/_common/endpoint_requestor.py,sha256=q-H4kT2Ip63omsodMZ8Bgo3HLMFhnOpaGoc2MqIZdmI,5317
+unique_toolkit/_common/endpoint_builder.py,sha256=WzJrJ7azUQhvQRd-vsFFoyj6omJpHiVYrh1UFxNQvVg,8242
+unique_toolkit/_common/endpoint_requestor.py,sha256=JbbfJGLxgxLz8a3Yx1FdJvdHGbCYO8MSBd7cLg_Mtp0,5927
 unique_toolkit/_common/exception.py,sha256=caQIE1btsQnpKCHqL2cgWUSbHup06enQu_Pt7uGUTTE,727
 unique_toolkit/_common/feature_flags/schema.py,sha256=F1NdVJFNU8PKlS7bYzrIPeDu2LxRqHSM9pyw622a1Kk,547
-unique_toolkit/_common/pydantic_helpers.py,sha256=4a8LPey31k4dCztYag1OBhYnGHREN08-l3NEjbFD1ok,743
+unique_toolkit/_common/pydantic_helpers.py,sha256=TVEYUaBnsXRXmjmdtaM0LV_0-7NX9SWfAgqNBrKReOE,4729
+unique_toolkit/_common/string_utilities.py,sha256=pbsjpnz1mwGeugebHzubzmmDtlm18B8e7xJdSvLnor0,2496
 unique_toolkit/_common/token/image_token_counting.py,sha256=VpFfZyY0GIH27q_Wy4YNjk2algqvbCtJyzuuROoFQPw,2189
 unique_toolkit/_common/token/token_counting.py,sha256=gM4B_aUqKqEPvmStFNcvCWNMNNNNKbVaywBDxlbgIps,7121
 unique_toolkit/_common/utils/structured_output/schema.py,sha256=Tp7kDYcmKtnUhcuRkH86TSYhylRff0ZZJYb2dLkISts,131
 unique_toolkit/_common/utils/write_configuration.py,sha256=fzvr4C-XBL3OSM3Od9TbqIxeeDS9_d9CLEyTq6DDknY,1409
 unique_toolkit/_common/validate_required_values.py,sha256=Y_M1ub9gIKP9qZ45F6Zq3ZHtuIqhmOjl8Z2Vd3avg8w,588
-unique_toolkit/_common/validators.py,sha256=aZwbMho7XszN7lT5RtemaiXgC0WJ4u40oeVgsNGhF4U,2803
+unique_toolkit/_common/validators.py,sha256=LFZmAalNa886EXm1VYamFvfBuUZjYKwDdT_HOYU0BtE,2934
 unique_toolkit/agentic/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 unique_toolkit/agentic/debug_info_manager/debug_info_manager.py,sha256=8u3_oxcln7y2zOsfiGh5YOm1zYAlV5QxZ5YAsbEJG0c,584
 unique_toolkit/agentic/evaluation/config.py,sha256=ywHIrJs5SFdKr1WXfrofWuFfzb0iPQw8iZDpq5oEug4,953
@@ -124,7 +126,7 @@ unique_toolkit/short_term_memory/schemas.py,sha256=OhfcXyF6ACdwIXW45sKzjtZX_gkcJ
 unique_toolkit/short_term_memory/service.py,sha256=5PeVBu1ZCAfyDb2HLVvlmqSbyzBBuE9sI2o9Aajqjxg,8884
 unique_toolkit/smart_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 unique_toolkit/smart_rules/compile.py,sha256=cxWjb2dxEI2HGsakKdVCkSNi7VK9mr08w5sDcFCQyWI,9553
-unique_toolkit-1.1.2.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-1.1.2.dist-info/METADATA,sha256=gka_NfFWIYCImnxZX-b-4Pwe20WrYHpN-gwgO7ljcso,32541
-unique_toolkit-1.1.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-1.1.2.dist-info/RECORD,,
+unique_toolkit-1.1.4.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
+unique_toolkit-1.1.4.dist-info/METADATA,sha256=2BBFs3a2HGMSWyyk2MQV5gAVJUINJC3Bua6hF4VklcI,32722
+unique_toolkit-1.1.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-1.1.4.dist-info/RECORD,,