unique_toolkit 0.7.13__py3-none-any.whl → 0.7.17__py3-none-any.whl

unique_toolkit/content/service.py

@@ -1,6 +1,7 @@
 import logging
 from pathlib import Path
 
+import unique_sdk
 from requests import Response
 from typing_extensions import deprecated
 
@@ -365,6 +366,7 @@ class ContentService:
         scope_id: str | None = None,
         chat_id: str | None = None,
         skip_ingestion: bool = False,
+        ingestion_config: unique_sdk.Content.IngestionConfig | None = None,
     ) -> Content:
         """
         Uploads content to the knowledge base.
@@ -390,6 +392,7 @@ class ContentService:
             scope_id=scope_id,
             chat_id=chat_id,
             skip_ingestion=skip_ingestion,
+            ingestion_config=ingestion_config,
         )
 
     def upload_content(
@@ -400,6 +403,7 @@ class ContentService:
         scope_id: str | None = None,
         chat_id: str | None = None,
         skip_ingestion: bool = False,
+        ingestion_config: unique_sdk.Content.IngestionConfig | None = None,
     ):
         """
         Uploads content to the knowledge base.
@@ -425,6 +429,7 @@ class ContentService:
             scope_id=scope_id,
             chat_id=chat_id,
             skip_ingestion=skip_ingestion,
+            ingestion_config=ingestion_config,
         )
 
     def request_content_by_id(

unique_toolkit/evaluators/config.py

@@ -1,35 +1,26 @@
 from humps import camelize
-from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic import BaseModel, ConfigDict
 
-from unique_toolkit._common.validators import validate_and_init_language_model
+from unique_toolkit._common.validators import LMI, LanguageModelInfo
 from unique_toolkit.evaluators.schemas import (
     EvaluationMetricName,
 )
 from unique_toolkit.language_model.infos import (
-    LanguageModel,
     LanguageModelName,
 )
 
-model_config = ConfigDict(
-    alias_generator=camelize,
-    populate_by_name=True,
-    arbitrary_types_allowed=True,
-    validate_default=True,
-    json_encoders={LanguageModel: lambda v: v.display_name},
-)
-
 
 class EvaluationMetricConfig(BaseModel):
-    model_config = model_config
+    model_config = ConfigDict(
+        alias_generator=camelize,
+        populate_by_name=True,
+        validate_default=True,
+    )
 
     enabled: bool = False
     name: EvaluationMetricName
-    language_model: LanguageModel = LanguageModel(
-        LanguageModelName.AZURE_GPT_35_TURBO_0125
+    language_model: LMI = LanguageModelInfo.from_name(
+        LanguageModelName.AZURE_GPT_35_TURBO_0125,
     )
     custom_prompts: dict[str, str] = {}
     score_to_emoji: dict[str, str] = {}
-
-    @field_validator("language_model", mode="before")
-    def validate_language_model(cls, value: LanguageModelName | LanguageModel):
-        return validate_and_init_language_model(value)

unique_toolkit/evaluators/context_relevancy/constants.py

@@ -7,7 +7,7 @@ from unique_toolkit.evaluators.schemas import (
     EvaluationMetricInputFieldName,
     EvaluationMetricName,
 )
-from unique_toolkit.language_model.infos import LanguageModel
+from unique_toolkit.language_model.infos import LanguageModelInfo
 from unique_toolkit.language_model.service import LanguageModelName
 
 SYSTEM_MSG_KEY = "systemPrompt"
@@ -23,7 +23,9 @@ context_relevancy_required_input_fields = [
 default_config = EvaluationMetricConfig(
     enabled=False,
     name=EvaluationMetricName.CONTEXT_RELEVANCY,
-    language_model=LanguageModel(LanguageModelName.AZURE_GPT_35_TURBO_0125),
+    language_model=LanguageModelInfo.from_name(
+        LanguageModelName.AZURE_GPT_35_TURBO_0125
+    ),
     score_to_emoji={"LOW": "🟢", "MEDIUM": "🟡", "HIGH": "🔴"},
     custom_prompts={
         SYSTEM_MSG_KEY: CONTEXT_RELEVANCY_METRIC_SYSTEM_MSG,

unique_toolkit/evaluators/context_relevancy/utils.py

@@ -22,6 +22,7 @@ from unique_toolkit.evaluators.schemas import (
     EvaluationMetricName,
     EvaluationMetricResult,
 )
+from unique_toolkit.language_model import LanguageModelName
 from unique_toolkit.language_model.schemas import (
     LanguageModelMessages,
     LanguageModelSystemMessage,
@@ -34,12 +35,12 @@ logger = logging.getLogger(__name__)
 
 async def check_context_relevancy_async(
     company_id: str,
-    input: EvaluationMetricInput,
+    evaluation_metric_input: EvaluationMetricInput,
     config: EvaluationMetricConfig,
     logger: logging.Logger = logger,
 ) -> EvaluationMetricResult | None:
-    """
-    Analyzes the relevancy of the context provided for the given input and output.
+    """Analyzes the relevancy of the context provided for the given evaluation_metric_input and output.
+
     The analysis classifies the context relevancy level as:
     - low
     - medium
@@ -47,14 +48,14 @@ async def check_context_relevancy_async(
 
     This method performs the following steps:
     1. Logs the start of the analysis using the provided `logger`.
-    2. Validates the required fields in the `input` data.
+    2. Validates the required fields in the `evaluation_metric_input` data.
     3. Retrieves the messages using the `_get_msgs` method.
     4. Calls `LanguageModelService.complete_async_util` to get a completion result.
     5. Parses and returns the evaluation metric result based on the content of the completion result.
 
     Args:
         company_id (str): The company ID for the analysis.
-        input (EvaluationMetricInput): The input data used for evaluation, including the generated output and reference information.
+        evaluation_metric_input (EvaluationMetricInput): The evaluation_metric_input data used for evaluation, including the generated output and reference information.
         config (EvaluationMetricConfig): Configuration settings for the evaluation.
         logger (Optional[logging.Logger], optional): The logger used for logging information and errors. Defaults to the logger for the current module.
 
@@ -63,13 +64,23 @@ async def check_context_relevancy_async(
 
     Raises:
         EvaluatorException: If required fields are missing or an error occurs during the evaluation.
+
     """
-    model_name = config.language_model.name
-    logger.info(f"Analyzing context relevancy with {model_name}.")
+    model_group_name = (
+        config.language_model.name.value
+        if isinstance(config.language_model.name, LanguageModelName)
+        else config.language_model.name
+    )
+    logger.info(f"Analyzing context relevancy with {model_group_name}.")
 
-    input.validate_required_fields(context_relevancy_required_input_fields)
+    evaluation_metric_input.validate_required_fields(
+        context_relevancy_required_input_fields,
+    )
 
-    if input.context_texts and len(input.context_texts) == 0:
+    if (
+        evaluation_metric_input.context_texts
+        and len(evaluation_metric_input.context_texts) == 0
+    ):
         error_message = "No context texts provided."
         raise EvaluatorException(
             user_message=error_message,
@@ -77,11 +88,11 @@ async def check_context_relevancy_async(
         )
 
     try:
-        msgs = _get_msgs(input, config)
+        msgs = _get_msgs(evaluation_metric_input, config)
         result = await LanguageModelService.complete_async_util(
             company_id=company_id,
             messages=msgs,
-            model_name=model_name,
+            model_name=model_group_name,
         )
         result_content = result.choices[0].message.content
         if not result_content:
@@ -104,25 +115,28 @@ async def check_context_relevancy_async(
 
 
 def _get_msgs(
-    input: EvaluationMetricInput,
+    evaluation_metric_input: EvaluationMetricInput,
     config: EvaluationMetricConfig,
-):
-    """
-    Composes the messages for context relevancy analysis based on the provided input and configuration.
+) -> LanguageModelMessages:
+    """Composes the messages for context relevancy analysis.
+
+    The messages are based on the provided evaluation_metric_input and configuration.
 
     Args:
-        input (EvaluationMetricInput): The input data that includes context texts for the analysis.
+        evaluation_metric_input (EvaluationMetricInput): The evaluation_metric_input data that includes context texts for the analysis.
         config (EvaluationMetricConfig): The configuration settings for composing messages.
 
     Returns:
-        LanguageModelMessages: The composed messages as per the provided input and configuration.
+        LanguageModelMessages: The composed messages as per the provided evaluation_metric_input and configuration.
+
     """
     system_msg_content = _get_system_prompt(config)
     system_msg = LanguageModelSystemMessage(content=system_msg_content)
 
     user_msg_templ = Template(_get_user_prompt(config))
     user_msg_content = user_msg_templ.substitute(
-        input_text=input.input_text, contexts_text=input.get_joined_context_texts()
+        evaluation_metric_input_text=evaluation_metric_input.evaluation_metric_input_text,
+        contexts_text=evaluation_metric_input.get_joined_context_texts(),
     )
     user_msg = LanguageModelUserMessage(content=user_msg_content)
     return LanguageModelMessages([system_msg, user_msg])

unique_toolkit/evaluators/hallucination/constants.py

@@ -10,7 +10,7 @@ from unique_toolkit.evaluators.schemas import (
     EvaluationMetricName,
 )
 from unique_toolkit.language_model.infos import (
-    LanguageModel,
+    LanguageModelInfo,
     LanguageModelName,
 )
 
@@ -23,7 +23,7 @@ USER_MSG_DEFAULT_KEY = "userPromptDefault"
 hallucination_metric_default_config = EvaluationMetricConfig(
     enabled=False,
     name=EvaluationMetricName.HALLUCINATION,
-    language_model=LanguageModel(LanguageModelName.AZURE_GPT_4_0613),
+    language_model=LanguageModelInfo.from_name(LanguageModelName.AZURE_GPT_4_0613),
     score_to_emoji={"LOW": "🟢", "MEDIUM": "🟡", "HIGH": "🔴"},
     custom_prompts={
         SYSTEM_MSG_KEY: HALLUCINATION_METRIC_SYSTEM_MSG,

unique_toolkit/evaluators/hallucination/utils.py

@@ -20,6 +20,7 @@ from unique_toolkit.evaluators.schemas import (
     EvaluationMetricName,
     EvaluationMetricResult,
 )
+from unique_toolkit.language_model import LanguageModelName
 from unique_toolkit.language_model.schemas import (
     LanguageModelMessages,
     LanguageModelSystemMessage,
@@ -43,8 +44,9 @@ async def check_hallucination_async(
     config: EvaluationMetricConfig,
     logger: logging.Logger = logger,
 ) -> EvaluationMetricResult | None:
-    """
-    Analyzes the level of hallucination in the generated output by comparing it with the provided input
+    """Analyze the level of hallucination in the generated output.
+
+    by comparing it with the provided input
     and the contexts or history. The analysis classifies the hallucination level as:
     - low
     - medium
@@ -72,16 +74,23 @@ async def check_hallucination_async(
 
     Raises:
         EvaluatorException: If the context texts are empty, required fields are missing, or an error occurs during the evaluation.
+
     """
-    model_name = config.language_model.name
-    logger.info(f"Analyzing level of hallucination with {model_name}.")
+    model_group_name = (
+        config.language_model.name.value
+        if isinstance(config.language_model.name, LanguageModelName)
+        else config.language_model.name
+    )
+    logger.info(f"Analyzing level of hallucination with {model_group_name}.")
 
     input.validate_required_fields(hallucination_required_input_fields)
 
     try:
         msgs = _get_msgs(input, config, logger)
         result = await LanguageModelService.complete_async_util(
-            company_id=company_id, messages=msgs, model_name=model_name
+            company_id=company_id,
+            messages=msgs,
+            model_name=model_group_name,
         )
         result_content = result.choices[0].message.content
         if not result_content:
@@ -104,71 +113,72 @@ async def check_hallucination_async(
 
 
 def _get_msgs(
-    input: EvaluationMetricInput,
+    evaluation_metric_input: EvaluationMetricInput,
     config: EvaluationMetricConfig,
     logger: logging.Logger,
 ):
-    """
-    Composes the messages for hallucination analysis based on the provided input and configuration.
+    """Composes the messages for hallucination analysis based on the provided evaluation_metric_input and configuration.
 
     This method decides how to compose the messages based on the availability of context texts and history
-    message texts in the `input`
+    message texts in the `evaluation_metric_input`
 
     Args:
-        input (EvaluationMetricInput): The input data that includes context texts and history message texts
+        evaluation_metric_input (EvaluationMetricInput): The evaluation_metric_input data that includes context texts and history message texts
                                       for the analysis.
         config (EvaluationMetricConfig): The configuration settings for composing messages.
         logger (Optional[logging.Logger], optional): The logger used for logging debug information.
                                                      Defaults to the logger for the current module.
 
     Returns:
-        The composed messages as per the provided input and configuration. The exact type and structure
+        The composed messages as per the provided evaluation_metric_input and configuration. The exact type and structure
         depend on the implementation of the `compose_msgs` and `compose_msgs_default` methods.
 
     """
-    if input.context_texts or input.history_messages:
+    if (
+        evaluation_metric_input.context_texts
+        or evaluation_metric_input.history_messages
+    ):
         logger.debug("Using context / history for hallucination evaluation.")
-        return _compose_msgs(input, config)
-    else:
-        logger.debug("No contexts and history provided for hallucination evaluation.")
-        return _compose_msgs_default(input, config)
+        return _compose_msgs(evaluation_metric_input, config)
+    logger.debug("No contexts and history provided for hallucination evaluation.")
+    return _compose_msgs_default(evaluation_metric_input, config)
 
 
 def _compose_msgs(
-    input: EvaluationMetricInput,
+    evaluation_metric_input: EvaluationMetricInput,
     config: EvaluationMetricConfig,
 ):
-    """
-    Composes the hallucination analysis messages.
-    """
+    """Composes the hallucination analysis messages."""
     system_msg_content = _get_system_prompt_with_contexts(config)
     system_msg = LanguageModelSystemMessage(content=system_msg_content)
 
     user_msg_templ = Template(_get_user_prompt_with_contexts(config))
     user_msg_content = user_msg_templ.substitute(
-        input_text=input.input_text,
-        contexts_text=input.get_joined_context_texts(tag_name="reference"),
-        history_messages_text=input.get_joined_history_texts(tag_name="conversation"),
-        output_text=input.output_text,
+        evaluation_metric_input_text=evaluation_metric_input.evaluation_metric_input_text,
+        contexts_text=evaluation_metric_input.get_joined_context_texts(
+            tag_name="reference",
+        ),
+        history_messages_text=evaluation_metric_input.get_joined_history_texts(
+            tag_name="conversation",
+        ),
+        output_text=evaluation_metric_input.output_text,
     )
     user_msg = LanguageModelUserMessage(content=user_msg_content)
     return LanguageModelMessages([system_msg, user_msg])
 
 
 def _compose_msgs_default(
-    input: EvaluationMetricInput,
+    evaluation_metric_input: EvaluationMetricInput,
     config: EvaluationMetricConfig,
 ):
-    """
-    Composes the hallucination analysis prompt without messages.
-    """
+    """Composes the hallucination analysis prompt without messages."""
     system_msg_content = _get_system_prompt_default(config)
     system_msg = LanguageModelSystemMessage(content=system_msg_content)
 
     user_msg_templ = Template(_get_user_prompt_default(config))
     user_msg_content = user_msg_templ.substitute(
-        input_text=input.input_text,
-        output_text=input.output_text,
+        evaluation_metric_input_text=evaluation_metric_input.evaluation_metric_input_text,
+        output_text=evaluation_metric_input.output_text,
     )
     user_msg = LanguageModelUserMessage(content=user_msg_content)
     return LanguageModelMessages([system_msg, user_msg])

unique_toolkit/language_model/functions.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Type, cast
+from typing import cast
 
 import unique_sdk
 from pydantic import BaseModel
@@ -29,11 +29,10 @@ def complete(
     timeout: int = DEFAULT_COMPLETE_TIMEOUT,
     tools: list[LanguageModelTool] | None = None,
     other_options: dict | None = None,
-    structured_output_model: Type[BaseModel] | None = None,
+    structured_output_model: type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
 ) -> LanguageModelResponse:
-    """
-    Calls the completion endpoint synchronously without streaming the response.
+    """Call the completion endpoint synchronously without streaming the response.
 
     Args:
         company_id (str): The company ID associated with the request.
@@ -46,6 +45,7 @@ def complete(
 
     Returns:
         LanguageModelResponse: The response object containing the completed result.
+
     """
     options, model, messages_dict, _ = _prepare_completion_params_util(
         messages=messages,
@@ -62,7 +62,7 @@ def complete(
             company_id=company_id,
             model=model,
             messages=cast(
-                list[unique_sdk.Integrated.ChatCompletionRequestMessage],
+                "list[unique_sdk.Integrated.ChatCompletionRequestMessage]",
                 messages_dict,
             ),
             timeout=timeout,
@@ -82,11 +82,10 @@ async def complete_async(
     timeout: int = DEFAULT_COMPLETE_TIMEOUT,
     tools: list[LanguageModelTool] | None = None,
     other_options: dict | None = None,
-    structured_output_model: Type[BaseModel] | None = None,
+    structured_output_model: type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
 ) -> LanguageModelResponse:
-    """
-    Calls the completion endpoint asynchronously without streaming the response.
+    """Call the completion endpoint asynchronously without streaming the response.
 
     This method sends a request to the completion endpoint using the provided messages, model name,
     temperature, timeout, and optional tools. It returns a `LanguageModelResponse` object containing
@@ -105,7 +104,9 @@ async def complete_async(
         LanguageModelResponse: The response object containing the completed result.
 
     Raises:
-        Exception: If an error occurs during the request, an exception is raised and logged.
+        Exception: If an error occurs during the request, an exception is raised
+        and logged.
+
     """
     options, model, messages_dict, _ = _prepare_completion_params_util(
         messages=messages,
@@ -122,7 +123,7 @@ async def complete_async(
             company_id=company_id,
             model=model,
             messages=cast(
-                list[unique_sdk.Integrated.ChatCompletionRequestMessage],
+                "list[unique_sdk.Integrated.ChatCompletionRequestMessage]",
                 messages_dict,
             ),
             timeout=timeout,
@@ -130,7 +131,7 @@ async def complete_async(
         )
         return LanguageModelResponse(**response)
     except Exception as e:
-        logger.error(f"Error completing: {e}")  # type: ignore
+        logger.exception(f"Error completing: {e}")
         raise e
 
 
@@ -163,14 +164,14 @@ def _to_search_context(chunks: list[ContentChunk]) -> dict | None:
             endPage=chunk.end_page,
             order=chunk.order,
             object=chunk.object,
-        )  # type: ignore
+        )
         for chunk in chunks
     ]
 
 
 def _add_response_format_to_options(
     options: dict,
-    structured_output_model: Type[BaseModel],
+    structured_output_model: type[BaseModel],
     structured_output_enforce_schema: bool = False,
 ) -> dict:
     options["responseFormat"] = {
@@ -191,11 +192,10 @@ def _prepare_completion_params_util(
     tools: list[LanguageModelTool] | None = None,
     other_options: dict | None = None,
     content_chunks: list[ContentChunk] | None = None,
-    structured_output_model: Type[BaseModel] | None = None,
+    structured_output_model: type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
 ) -> tuple[dict, str, dict, dict | None]:
-    """
-    Prepares common parameters for completion requests.
+    """Prepare common parameters for completion requests.
 
     Returns:
         tuple containing:
@@ -203,18 +203,22 @@ def _prepare_completion_params_util(
         - model (str): Resolved model name
         - messages_dict (dict): Processed messages
         - search_context (dict | None): Processed content chunks if provided
-    """
 
+    """
     options = _add_tools_to_options({}, tools)
     if structured_output_model:
         options = _add_response_format_to_options(
-            options, structured_output_model, structured_output_enforce_schema
+            options,
+            structured_output_model,
+            structured_output_enforce_schema,
         )
     options["temperature"] = temperature
     if other_options:
         options.update(other_options)
 
-    model = model_name.name if isinstance(model_name, LanguageModelName) else model_name
+    model = (
+        model_name.value if isinstance(model_name, LanguageModelName) else model_name
+    )
 
     # Different methods need different message dump parameters
     messages_dict = messages.model_dump(

unique_toolkit/language_model/infos.py

@@ -492,8 +492,10 @@ class LanguageModelInfo(BaseModel):
 
 @deprecated(
     """
-Use `LanguageModelInfo` instead of `LanguageModel`
-"""
+Use `LanguageModelInfo` instead of `LanguageModel`.
+
+`LanguageModel` will be deprecated on 31.12.2025
+""",
 )
 class LanguageModel:
     _info: ClassVar[LanguageModelInfo]
@@ -503,8 +505,8 @@ class LanguageModel:
 
     @property
     def info(self) -> LanguageModelInfo:
-        """
-        Returns all infos about the model:
+        """Return all infos about the model.
+
         - name
         - version
         - provider