unique_toolkit 1.8.1__py3-none-any.whl → 1.23.0__py3-none-any.whl

unique_toolkit/__init__.py

@@ -2,14 +2,27 @@
 from unique_toolkit.chat import ChatService
 from unique_toolkit.content import ContentService
 from unique_toolkit.embedding import EmbeddingService
+from unique_toolkit.framework_utilities.openai.client import (
+    get_async_openai_client,
+    get_openai_client,
+)
 from unique_toolkit.language_model import (
     LanguageModelMessages,
     LanguageModelName,
     LanguageModelService,
     LanguageModelToolDescription,
 )
+from unique_toolkit.services.knowledge_base import KnowledgeBaseService
 from unique_toolkit.short_term_memory import ShortTermMemoryService
 
+# Conditionally import langchain utilities if langchain is installed
+try:
+    from unique_toolkit.framework_utilities.langchain.client import get_langchain_client  # noqa: F401, I001
+
+    _LANGCHAIN_AVAILABLE = True
+except ImportError:
+    _LANGCHAIN_AVAILABLE = False
+
 # You can add other classes you frequently use here as well
 
 __all__ = [
@@ -21,4 +34,11 @@ __all__ = [
     "ContentService",
     "EmbeddingService",
     "ShortTermMemoryService",
+    "KnowledgeBaseService",
+    "get_openai_client",
+    "get_async_openai_client",
 ]
+
+# Add langchain-specific exports if available
+if _LANGCHAIN_AVAILABLE:
+    __all__.append("get_langchain_client")

unique_toolkit/_common/api_calling/human_verification_manager.py

@@ -4,7 +4,7 @@ from logging import Logger
 from typing import Any, Generic
 
 import jinja2
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
 from unique_toolkit._common.endpoint_builder import (
     ApiOperationProtocol,
@@ -15,10 +15,14 @@ from unique_toolkit._common.endpoint_builder import (
     ResponseType,
 )
 from unique_toolkit._common.endpoint_requestor import (
+    RequestContext,
     RequestorType,
     build_requestor,
 )
-from unique_toolkit._common.pydantic_helpers import create_union_model
+from unique_toolkit._common.pydantic_helpers import (
+    create_complement_model,
+    create_union_model,
+)
 from unique_toolkit._common.string_utilities import (
     dict_to_markdown_table,
     extract_dicts_from_string,
@@ -37,11 +41,13 @@ NEXT_USER_MESSAGE_JINJA2_TEMPLATE = jinja2.Template("""I confirm the api call wi
 ```""")
 
 
-ASSISTANT_CONFIRMATION_MESSAGE_JINJA2_TEMPLATE = jinja2.Template("""I would like to call the api with the following data:
-
+ASSISTANT_CONFIRMATION_MESSAGE_JINJA2_TEMPLATE = jinja2.Template(
+    """
+\n
 {{ api_call_as_markdown_table }}
-
-[{{ button_text }}](https://prompt={{ next_user_message | urlencode }})""")
+\n\n
+[{{ button_text }}](https://prompt={{ next_user_message | urlencode }})"""
+)
 
 
 class HumanVerificationManagerForApiCalling(
@@ -77,24 +83,67 @@ class HumanVerificationManagerForApiCalling(
             ]
         ],
         requestor_type: RequestorType = RequestorType.REQUESTS,
+        environment_payload_params: BaseModel | None = None,
+        modifiable_payload_params_model: type[BaseModel] | None = None,
         **kwargs: dict[str, Any],
     ):
+        """
+        Manages human verification for api calling.
+
+        Args:
+            logger: The logger to use for logging.
+            operation: The operation to use for the api calling.
+            requestor_type: The requestor type to use for the api calling.
+            environment_payload_params: The environment payload params to use for the api calling.
+                If None, the modifiable params model will be the operation payload model.
+                This can be useful for parameters in the payload that should not be modified by the user.
+            modifiable_payload_params_model: The modifiable payload params model to use for the api calling.
+                If None, a complement model will be created using the operation payload model
+                and the environment payload params.
+                If provided, it will be used instead of the complement model.
+                This is necessary if the modifiable params model is required
+                to use custom validators or serializers.
+            **kwargs: Additional keyword arguments to pass to the requestor.
+        """
         self._logger = logger
         self._operation = operation
-
+        self._environment_payload_params = environment_payload_params
         # Create internal models for this manager instance
 
-        class ConcreteApiCall(BaseModel):
+        if self._environment_payload_params is None:
+            self._modifiable_payload_params_model = self._operation.payload_model()
+        else:
+            if modifiable_payload_params_model is None:
+                self._modifiable_payload_params_model = create_complement_model(
+                    model_type_a=self._operation.payload_model(),
+                    model_type_b=type(self._environment_payload_params),
+                )
+            else:
+                # This is necessary if the modifiable params model is required
+                # to use custom validators or serializers.
+                self._modifiable_payload_params_model = modifiable_payload_params_model
+
+        if self._environment_payload_params is not None:
+            combined_keys = set(
+                self._modifiable_payload_params_model.model_fields.keys()
+            ) | set(type(self._environment_payload_params).model_fields.keys())
+            payload_keys = set(self._operation.payload_model().model_fields.keys())
+            if not payload_keys.issubset(combined_keys):
+                raise ValueError(
+                    "The modifiable params model + the environment parameters do not have all the keys of the operation payload model."
+                )
+
+        class VerificationModel(BaseModel):
             confirmation: HumanConfirmation
-            payload: self._operation.payload_model()  # type: ignore
+            modifiable_params: self._modifiable_payload_params_model  # type: ignore
 
-        self._api_call_model = ConcreteApiCall
+        self._verification_model = VerificationModel
 
+        self._requestor_type = requestor_type
         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,
@@ -103,7 +152,10 @@ class HumanVerificationManagerForApiCalling(
         )
 
     def detect_api_calls_from_user_message(
-        self, *, last_assistant_message: ChatMessage, user_message: str
+        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:
@@ -113,13 +165,22 @@ class HumanVerificationManagerForApiCalling(
         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(
+                verfication_data = self._verification_model.model_validate(
                     user_message_dict, by_alias=True, by_name=True
                 )
                 if self._verify_human_verification(
-                    api_call.confirmation, last_assistant_message
+                    verfication_data.confirmation, last_assistant_message
                 ):
-                    return api_call.payload
+                    payload_dict = verfication_data.modifiable_params.model_dump()
+                    if self._environment_payload_params is not None:
+                        payload_dict.update(
+                            self._environment_payload_params.model_dump()
+                        )
+
+                    return self._operation.payload_model().model_validate(
+                        payload_dict, by_alias=True, by_name=True
+                    )
+
             except Exception as e:
                 self._logger.error(f"Error detecting api calls from user message: {e}")
 
@@ -140,11 +201,29 @@ class HumanVerificationManagerForApiCalling(
         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,
+        # Extract only the modifiable fields from the payload
+        payload_dict = payload.model_dump()
+        if self._environment_payload_params is not None:
+            # Remove environment params from payload to avoid validation errors
+            environment_fields = set(
+                type(self._environment_payload_params).model_fields.keys()
+            )
+            modifiable_dict = {
+                k: v for k, v in payload_dict.items() if k not in environment_fields
+            }
+        else:
+            modifiable_dict = payload_dict
+
+        modifiable_params = self._modifiable_payload_params_model.model_validate(
+            modifiable_dict,
+            by_alias=True,
+            by_name=True,
+        )
+        api_call = self._verification_model(
+            modifiable_params=modifiable_params,
             confirmation=HumanConfirmation(
                 payload_hash=hashlib.sha256(
-                    payload.model_dump_json().encode()
+                    modifiable_params.model_dump_json().encode()
                 ).hexdigest(),
                 time_stamp=datetime.now(),
             ),
@@ -153,28 +232,42 @@ class HumanVerificationManagerForApiCalling(
             api_call_as_json=api_call.model_dump_json(indent=2)
         )
 
-    def create_assistant_confirmation_message(self, *, payload: PayloadType) -> str:
+    def create_assistant_confirmation_message(
+        self, *, payload: PayloadType, button_text: str = "Confirm"
+    ) -> 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.",
+            button_text=button_text,
             next_user_message=self._create_next_user_message(payload),
         )
 
     def call_api(
         self,
         *,
-        headers: dict[str, str],
+        context: RequestContext,
         path_params: PathParamsType,
         payload: PayloadType,
     ) -> ResponseType:
+        """
+        Call the api with the given path params, payload and secured payload params.
+
+        The `secured payload params` are params that are enforced by the application.
+        It should generally be not possible for the user to adapt those but here we
+        ensure that the application has the last word.
+
+        """
         params = path_params.model_dump()
         params.update(payload.model_dump())
 
         response = self._requestor.request(
-            headers=headers,
+            context=context,
             **params,
         )
-        return self._operation.handle_response(response)
+        try:
+            return self._operation.handle_response(response)
+        except ValidationError as e:
+            self._logger.error(f"Error calling api: {e}. Response: {response}")
+            raise e
 
 
 if __name__ == "__main__":
@@ -199,9 +292,9 @@ if __name__ == "__main__":
     class CombinedParams(GetUserPathParams, GetUserRequestBody):
         pass
 
-    UserEndpoint = build_api_operation(
+    UserApiOperation = build_api_operation(
         method=EndpointMethods.GET,
-        url_template=Template("https://api.example.com/users/{user_id}"),
+        path_template=Template("/users/{user_id}"),
         path_params_constructor=GetUserPathParams,
         payload_constructor=GetUserRequestBody,
         response_model_type=UserResponse,
@@ -209,15 +302,15 @@ if __name__ == "__main__":
 
     human_verification_manager = HumanVerificationManagerForApiCalling(
         logger=logging.getLogger(__name__),
-        operation=UserEndpoint,
+        operation=UserApiOperation,
         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,
+    api_call = human_verification_manager._verification_model(
+        modifiable_params=payload,
         confirmation=HumanConfirmation(
             payload_hash=hashlib.sha256(payload.model_dump_json().encode()).hexdigest(),
             time_stamp=datetime.now(),

unique_toolkit/_common/chunk_relevancy_sorter/config.py

@@ -2,12 +2,12 @@ from typing import Annotated, Any
 
 from pydantic import BaseModel, Field
 
-from unique_toolkit._common.default_language_model import DEFAULT_GPT_35_TURBO
 from unique_toolkit._common.validators import LMI, get_LMI_default_field
 from unique_toolkit.agentic.evaluation.context_relevancy.schema import (
     StructuredOutputConfig,
 )
 from unique_toolkit.agentic.tools.config import get_configuration_dict
+from unique_toolkit.language_model.default_language_model import DEFAULT_GPT_4o
 
 
 class ChunkRelevancySortConfig(BaseModel):
@@ -25,11 +25,11 @@ class ChunkRelevancySortConfig(BaseModel):
         description="The relevancy level order.",
     )
     language_model: LMI = get_LMI_default_field(
-        DEFAULT_GPT_35_TURBO,
+        DEFAULT_GPT_4o,
         description="The language model to use for the chunk relevancy sort.",
     )
     fallback_language_model: LMI = get_LMI_default_field(
-        DEFAULT_GPT_35_TURBO,
+        DEFAULT_GPT_4o,
         description="The language model to use as a fallback.",
     )
     additional_llm_options: dict[str, Any] = Field(

unique_toolkit/_common/chunk_relevancy_sorter/tests/test_service.py

@@ -13,10 +13,6 @@ from unique_toolkit._common.chunk_relevancy_sorter.schemas import (
     ChunkRelevancySorterResult,
 )
 from unique_toolkit._common.chunk_relevancy_sorter.service import ChunkRelevancySorter
-from unique_toolkit._common.default_language_model import (
-    DEFAULT_GPT_35_TURBO,
-    DEFAULT_GPT_4o,
-)
 from unique_toolkit.agentic.evaluation.context_relevancy.schema import (
     StructuredOutputConfig,
 )
@@ -26,6 +22,7 @@ from unique_toolkit.agentic.evaluation.schemas import (
 )
 from unique_toolkit.app.schemas import ChatEvent
 from unique_toolkit.content.schemas import ContentChunk
+from unique_toolkit.language_model.default_language_model import DEFAULT_GPT_4o
 from unique_toolkit.language_model.infos import LanguageModelInfo
 
 
@@ -60,7 +57,7 @@ def config():
         relevancy_levels_to_consider=["high", "medium", "low"],
         relevancy_level_order={"high": 0, "medium": 1, "low": 2},
         language_model=LanguageModelInfo.from_name(DEFAULT_GPT_4o),
-        fallback_language_model=LanguageModelInfo.from_name(DEFAULT_GPT_35_TURBO),
+        fallback_language_model=LanguageModelInfo.from_name(DEFAULT_GPT_4o),
         structured_output_config=StructuredOutputConfig(
             enabled=False,
             extract_fact_list=False,

unique_toolkit/_common/default_language_model.py

@@ -1,6 +1,12 @@
+import warnings
+
 from unique_toolkit.language_model.infos import LanguageModelName
 
-DEFAULT_GPT_35_TURBO = LanguageModelName.AZURE_GPT_35_TURBO_0125
+warnings.warn(
+    "unique_toolkit._common.default_language_model is deprecated. "
+    "Import DEFAULT_GPT_4o from unique_toolkit.language_model instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
 DEFAULT_GPT_4o = LanguageModelName.AZURE_GPT_4o_2024_1120
-DEFAULT_GPT_4o_STRUCTURED_OUTPUT = LanguageModelName.AZURE_GPT_4o_2024_0806
-DEFAULT_GPT_4o_MINI = LanguageModelName.AZURE_GPT_4o_MINI_2024_0718

unique_toolkit/_common/docx_generator/__init__.py

@@ -0,0 +1,7 @@
+from unique_toolkit._common.docx_generator.config import DocxGeneratorConfig
+from unique_toolkit._common.docx_generator.service import DocxGeneratorService
+
+__all__ = [
+    "DocxGeneratorService",
+    "DocxGeneratorConfig",
+]

unique_toolkit/_common/docx_generator/config.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+
+from unique_toolkit._common.pydantic_helpers import get_configuration_dict
+
+
+class DocxGeneratorConfig(BaseModel):
+    model_config = get_configuration_dict()
+
+    template_content_id: str = Field(
+        default="",
+        description="The content id of the template file uploaded to the knowledge base.",
+    )

unique_toolkit/_common/docx_generator/schemas.py

@@ -0,0 +1,80 @@
+from docx.document import Document as DocumentObject
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+from docxtpl import DocxTemplate
+from pydantic import BaseModel
+
+
+class HeadingField(BaseModel):
+    text: str
+    level: int = 4
+    alignment: WD_PARAGRAPH_ALIGNMENT = WD_PARAGRAPH_ALIGNMENT.LEFT
+
+    def add(self, doc: DocumentObject):
+        p = doc.add_heading(self.text, level=self.level)
+        p.alignment = self.alignment
+        return p
+
+    def __str__(self):
+        return f"HeadingField(text={self.text}, level={self.level}, alignment={self.alignment})"
+
+
+class ParagraphField(BaseModel):
+    text: str
+    style: str | None = None
+    alignment: WD_PARAGRAPH_ALIGNMENT = WD_PARAGRAPH_ALIGNMENT.LEFT
+
+    def add(self, doc: DocumentObject):
+        p = doc.add_paragraph(self.text, style=self.style)
+        p.alignment = self.alignment
+        return p
+
+    def __str__(self):
+        return f"ParagraphField(text={self.text}, style={self.style}, alignment={self.alignment})"
+
+
+class RunField(BaseModel):
+    text: str
+    italic: bool | None = False
+    bold: bool | None = False
+    alignment: WD_PARAGRAPH_ALIGNMENT = WD_PARAGRAPH_ALIGNMENT.LEFT
+
+    def __str__(self):
+        return f"RunField(text={self.text}, italic={self.italic}, alignment={self.alignment})"
+
+
+class RunsField(BaseModel):
+    runs: list[RunField]
+    style: str | None = None
+    alignment: WD_PARAGRAPH_ALIGNMENT = WD_PARAGRAPH_ALIGNMENT.LEFT
+
+    def add(self, doc: DocumentObject):
+        if not self.runs:
+            return None
+        p = doc.add_paragraph(style=self.style)
+        for run in self.runs:
+            r = p.add_run(run.text)
+            if run.italic:
+                r.italic = True
+            if run.bold:
+                r.bold = True
+        return p
+
+    def __str__(self):
+        return f"RunsField(runs={self.runs}, style={self.style}, alignment={self.alignment})"
+
+
+class ContentField(BaseModel):
+    contents: list[HeadingField | ParagraphField | RunsField]
+
+    def add(self, doc: DocxTemplate):
+        sd = doc.new_subdoc()
+        for content in self.contents:
+            # if isinstance(content, ImageField):
+            #     content.download_image(self.download_path)
+            #     content.add(sd) # type: ignore
+            # else:
+            content.add(sd)  # type: ignore
+        return sd
+
+    def __str__(self):
+        return f"ContentField(contents={self.contents})"