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

unique_toolkit/_common/docx_generator/service.py

@@ -0,0 +1,252 @@
+import io
+import logging
+import re
+from pathlib import Path
+
+from docxtpl import DocxTemplate
+from markdown_it import MarkdownIt
+
+from unique_toolkit._common.docx_generator.config import DocxGeneratorConfig
+from unique_toolkit._common.docx_generator.schemas import (
+    ContentField,
+    HeadingField,
+    # ImageField,
+    ParagraphField,
+    RunField,
+    RunsField,
+)
+from unique_toolkit.chat.service import ChatService
+from unique_toolkit.services import KnowledgeBaseService
+
+generator_dir_path = Path(__file__).resolve().parent
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DocxGeneratorService:
+    def __init__(
+        self,
+        chat_service: ChatService,
+        knowledge_base_service: KnowledgeBaseService,
+        config: DocxGeneratorConfig,
+    ):
+        self._knowledge_base_service = knowledge_base_service
+        self._config = config
+
+    @staticmethod
+    def parse_markdown_to_list_content_fields(
+        markdown: str, offset_header_lvl: int = 0
+    ) -> list[HeadingField | ParagraphField | RunsField]:
+        # Initialize markdown-it parser
+        md = MarkdownIt()
+
+        # Preprocess markdown.
+        # - Replace all headings with the correct heading level
+        # - Remove "Relevant sources" heading
+        # - Replace "# Proposed answer" with "#### Proposed answer"
+        markdown = re.sub(r"(?m)^\s*## ", "#### ", markdown)
+        markdown = re.sub(r"(?m)^\s*### ", "##### ", markdown)
+        markdown = markdown.replace("# Relevant sources", "")
+        markdown = markdown.replace("# Proposed answer", "#### Proposed answer")
+
+        tokens = md.parse(markdown)
+
+        elements = []
+        current_section = {}
+        in_list = False
+        bullet_list_indent_level = 0
+        list_item_open = False
+
+        for token in tokens:
+            if token.type == "bullet_list_open":
+                in_list = True
+                bullet_list_indent_level = int(token.level / 2)
+
+            elif token.type == "bullet_list_close":
+                in_list = False
+                bullet_list_indent_level = 0
+
+            elif token.type == "list_item_open":
+                if list_item_open:
+                    elements.append(current_section)
+                list_item_open = True
+                list_level = token.level - bullet_list_indent_level
+                current_section = {
+                    "type": RunsField,
+                    "runs": [],
+                    "is_list_item": True,
+                    "level": list_level,
+                }
+
+            elif token.type == "list_item_close":
+                if current_section and current_section.get("runs"):
+                    elements.append(current_section)
+                current_section = {}
+                list_item_open = False
+
+            if token.type == "heading_open":
+                # Heading start, token.tag gives the level (e.g., 'h1', 'h2', etc.)
+                header_lvl = int(token.tag[1])  # Extract the level number from tag
+                current_section = {
+                    "type": HeadingField,
+                    "text": "",
+                    "level": header_lvl + offset_header_lvl,
+                }
+
+            elif token.type == "heading_close":
+                if current_section:
+                    elements.append(current_section)
+                current_section = {}
+
+            elif token.type == "paragraph_open":
+                if not in_list:  # Only create new paragraph if not in a list
+                    current_section = {"type": RunsField, "runs": []}
+
+            elif token.type == "paragraph_close":
+                if not in_list and current_section:  # Only append if not in a list
+                    elements.append(current_section)
+                    current_section = {}
+
+            elif token.type == "inline":
+                if current_section.get("type") == HeadingField:
+                    content = token.content
+                    if content.startswith("_page"):
+                        # replace "_pageXXXX_" with "PageXXXX", where XXXX can be any characters and numbers
+                        content = re.sub(
+                            r"^_page([a-zA-Z0-9\s-]+)_(.*?)",
+                            r"Page\1",
+                            content,
+                        )
+                        bold = True
+                    current_section["text"] += content
+                elif "runs" in current_section:
+                    bold = False
+                    italic = False
+                    runs = []
+                    if token.children:
+                        for child in token.children:
+                            content = child.content
+                            if child.type == "strong_open":
+                                bold = True
+                            elif child.type == "strong_close":
+                                bold = False
+                            elif child.type == "em_open":
+                                italic = True
+                            elif child.type == "em_close":
+                                italic = False
+                            if child.type == "softbreak":
+                                content += "\n"
+                            if content:  # Only add non-empty content
+                                runs.append(
+                                    RunField(
+                                        text=content,
+                                        bold=bold,
+                                        italic=italic,
+                                    )
+                                )
+                    else:
+                        runs.append(
+                            RunField(
+                                text=token.content,
+                                bold=bold,
+                                italic=italic,
+                            )
+                        )
+
+                    current_section["runs"].extend(runs)
+
+        # Process remaining elements
+        contents = []
+        for element in elements:
+            if not element:
+                continue
+            if element["type"] == HeadingField:
+                contents.append(
+                    HeadingField(
+                        text=element["text"],
+                        level=element["level"],
+                    )
+                )
+            elif element["type"] == RunsField:
+                if element.get("is_list_item", False):
+                    level: int = min(element.get("level", 1), 5)
+                    if level > 1:
+                        style = "List Bullet " + str(level)
+                    else:
+                        style = "List Bullet"
+                    contents.append(RunsField(style=style, runs=element["runs"]))
+                else:
+                    contents.append(RunsField(runs=element["runs"]))
+
+        return contents
+
+    def generate_from_template(
+        self,
+        subdoc_content: list[HeadingField | ParagraphField | RunsField],
+        fields: dict | None = None,
+    ):
+        """
+        Generate a docx file from a template with the given content.
+
+        Args:
+            subdoc_content (list[HeadingField | ParagraphField | RunsField]): The content to be added to the docx file.
+            fields (dict): Other fields to be added to the docx file. Defaults to None.
+        """
+
+        docx_template_object = self._get_template(self._config.template_content_id)
+
+        doc = DocxTemplate(io.BytesIO(docx_template_object))
+
+        try:
+            content = {}
+            content["body"] = ContentField(contents=subdoc_content)
+
+            if fields:
+                content.update(fields)
+
+            for key, value in content.items():
+                if isinstance(value, ContentField):
+                    content[key] = value.add(doc)
+
+            doc.render(content)
+            docx_rendered_object = io.BytesIO()
+
+            doc.save(docx_rendered_object)
+            docx_rendered_object.seek(0)
+
+            return docx_rendered_object.getvalue()
+
+        except Exception as e:
+            _LOGGER.error(f"Error generating docx: {e}")
+            return None
+
+    def _get_template(self, template_content_id: str):
+        try:
+            if template_content_id:
+                _LOGGER.info(
+                    f"Downloading template from content ID: {template_content_id}"
+                )
+                file_content = self._knowledge_base_service.download_content_to_bytes(
+                    content_id=template_content_id
+                )
+            else:
+                _LOGGER.info("No template content ID provided. Using default template.")
+                file_content = self._get_default_template()
+        except Exception as e:
+            _LOGGER.warning(
+                f"An error occurred while downloading the template {e}. Make sure the template content ID is valid. Falling back to default template."
+            )
+            file_content = self._get_default_template()
+
+        return file_content
+
+    def _get_default_template(self):
+        generator_dir_path = Path(__file__).resolve().parent
+        path = generator_dir_path / "template" / "Doc Template.docx"
+
+        file_content = path.read_bytes()
+
+        _LOGGER.info("Template downloaded from default template")
+
+        return file_content

unique_toolkit/_common/endpoint_builder.py

@@ -3,8 +3,9 @@ This module provides a minimal framework for building endpoint classes such that
 the endpoints without having to know the details of the endpoints.
 """
 
+import warnings
 from enum import StrEnum
-from string import Formatter, Template
+from string import Template
 from typing import (
     Any,
     Callable,
@@ -15,8 +16,7 @@ from typing import (
     cast,
 )
 
-from pydantic import BaseModel
-from typing_extensions import deprecated
+from pydantic import BaseModel, ValidationError
 
 # Paramspecs
 PayloadParamSpec = ParamSpec("PayloadParamSpec")
@@ -47,6 +47,42 @@ class HttpMethods(StrEnum):
 EndpointMethods = HttpMethods
 
 
+class ResponseValidationException(Exception):
+    """
+    This exception is raised when the response validation fails.
+    """
+
+    def __init__(
+        self, operation_name: str, response: dict[str, Any], pydantic_error: str
+    ):
+        super().__init__(
+            f"Response validation failed for operation {operation_name}\n"
+            f"Response: {response}\n"
+            f"Pydantic error: {pydantic_error}"
+        )
+        self._operation_name = operation_name
+        self._response = response
+        self._pydantic_error = pydantic_error
+
+    @property
+    def operation_name(self) -> str:
+        return self._operation_name
+
+    @property
+    def response(self) -> dict[str, Any]:
+        return self._response
+
+    @property
+    def pydantic_error(self) -> str:
+        return self._pydantic_error
+
+    def __str__(self):
+        return (
+            f"Response validation failed for {self._operation_name}\n"
+            + f"Response: {self._response}"
+        )
+
+
 class ApiOperationProtocol(
     Protocol,
     Generic[
@@ -57,22 +93,33 @@ class ApiOperationProtocol(
         ResponseType,
     ],
 ):
+    @staticmethod
+    def path_dump_options() -> dict[str, Any]: ...
+
     @staticmethod
     def path_params_model() -> type[PathParamsType]: ...
 
+    @staticmethod
+    def payload_dump_options() -> dict[str, Any]: ...
+
     @staticmethod
     def payload_model() -> type[PayloadType]: ...
 
+    @staticmethod
+    def response_validate_options() -> dict[str, Any]: ...
+
     @staticmethod
     def response_model() -> type[ResponseType]: ...
 
     @staticmethod
-    def create_url(
+    def create_path(
         *args: PathParamsSpec.args, **kwargs: PathParamsSpec.kwargs
     ) -> str: ...
 
     @staticmethod
-    def create_url_from_model(path_params: PathParamsType) -> str: ...
+    def create_path_from_model(
+        path_params: PathParamsType, *, model_dump_options: dict | None = None
+    ) -> str: ...
 
     @staticmethod
     def create_payload(
@@ -80,10 +127,14 @@ class ApiOperationProtocol(
     ) -> dict[str, Any]: ...
 
     @staticmethod
-    def create_payload_from_model(payload: PayloadType) -> dict[str, Any]: ...
+    def create_payload_from_model(
+        payload: PayloadType, *, model_dump_options: dict | None = None
+    ) -> dict[str, Any]: ...
 
     @staticmethod
-    def handle_response(response: dict[str, Any]) -> ResponseType: ...
+    def handle_response(
+        response: dict[str, Any], *, model_validate_options: dict | None = None
+    ) -> ResponseType: ...
 
     @staticmethod
     def request_method() -> EndpointMethods: ...
@@ -98,11 +149,14 @@ class ApiOperationProtocol(
 def build_api_operation(
     *,
     method: HttpMethods,
-    url_template: Template,
+    path_template: Template,
     path_params_constructor: Callable[PathParamsSpec, PathParamsType],
     payload_constructor: Callable[PayloadParamSpec, PayloadType],
     response_model_type: type[ResponseType],
-    dump_options: dict | None = None,
+    payload_dump_options: dict | None = None,
+    path_dump_options: dict | None = None,
+    response_validate_options: dict | None = None,
+    dump_options: dict | None = None,  # Deprecated
 ) -> type[
     ApiOperationProtocol[
         PathParamsSpec,
@@ -128,64 +182,109 @@ def build_api_operation(
             "by_alias": True,
             "exclude_defaults": True,
         }
+    else:
+        warnings.warn(
+            "dump_options is deprecated. Use payload_dump_options instead.",
+            DeprecationWarning,
+        )
 
     class Operation(ApiOperationProtocol):
+        @staticmethod
+        def path_dump_options() -> dict[str, Any]:
+            return path_dump_options or {}
+
         @staticmethod
         def path_params_model() -> type[PathParamsType]:
             return cast(type[PathParamsType], path_params_constructor)
 
+        @staticmethod
+        def payload_dump_options() -> dict[str, Any]:
+            return payload_dump_options or {}
+
         @staticmethod
         def payload_model() -> type[PayloadType]:
             return cast(type[PayloadType], payload_constructor)
 
+        @staticmethod
+        def response_validate_options() -> dict[str, Any]:
+            return response_validate_options or {}
+
         @staticmethod
         def response_model() -> type[ResponseType]:
             return response_model_type
 
         @staticmethod
-        def create_url(
-            *args: PathParamsSpec.args,
-            **kwargs: PathParamsSpec.kwargs,
+        def path_template() -> Template:
+            return path_template
+
+        @staticmethod
+        def create_path_from_model(
+            path_params: PathParamsType, *, model_dump_options: dict | None = None
         ) -> str:
-            """Create URL from path parameters."""
-            path_model = Operation.path_params_model()(*args, **kwargs)
-            path_dict = path_model.model_dump(**dump_options)
-
-            # Extract expected path parameters from template
-            template_params = [
-                fname
-                for _, fname, _, _ in Formatter().parse(url_template.template)
-                if fname is not None
-            ]
-
-            # Verify all required path parameters are present
-            missing_params = [
-                param for param in template_params if param not in path_dict
-            ]
-            if missing_params:
-                raise ValueError(f"Missing path parameters: {missing_params}")
-
-            return url_template.substitute(**path_dict)
+            if model_dump_options is None:
+                if path_dump_options is None:
+                    model_dump_options = dump_options
+                else:
+                    model_dump_options = path_dump_options
+
+            return path_template.substitute(
+                **path_params.model_dump(**model_dump_options)
+            )
 
         @staticmethod
-        def create_url_from_model(path_params: PathParamsType) -> str:
-            return url_template.substitute(**path_params.model_dump(**dump_options))
+        def create_path(
+            *args: PathParamsSpec.args, **kwargs: PathParamsSpec.kwargs
+        ) -> str:
+            model = Operation.path_params_model()(*args, **kwargs)
+            return Operation.create_path_from_model(model)
 
         @staticmethod
         def create_payload(
-            *args: PayloadParamSpec.args, **kwargs: PayloadParamSpec.kwargs
+            *args: PayloadParamSpec.args,
+            **kwargs: PayloadParamSpec.kwargs,
         ) -> dict[str, Any]:
             """Create request body payload."""
+            if payload_dump_options is None:
+                model_dump_options = dump_options
+            else:
+                model_dump_options = payload_dump_options
+
             request_model = Operation.payload_model()(*args, **kwargs)
-            return request_model.model_dump(**dump_options)
+            return request_model.model_dump(**model_dump_options)
 
         @staticmethod
-        def create_payload_from_model(payload: PayloadType) -> dict[str, Any]:
-            return payload.model_dump(**dump_options)
+        def create_payload_from_model(
+            payload: PayloadType, *, model_dump_options: dict | None = None
+        ) -> dict[str, Any]:
+            if model_dump_options is None:
+                if payload_dump_options is None:
+                    model_dump_options = dump_options
+                else:
+                    model_dump_options = payload_dump_options
+
+            return payload.model_dump(**model_dump_options)
 
         @staticmethod
-        def handle_response(response: dict[str, Any]) -> ResponseType:
-            return Operation.response_model().model_validate(response)
+        def handle_response(
+            response: dict[str, Any],
+            *,
+            model_validate_options: dict[str, Any] | None = None,
+        ) -> ResponseType:
+            if model_validate_options is None:
+                if response_validate_options is None:
+                    model_validate_options = {}
+                else:
+                    model_validate_options = response_validate_options
+            try:
+                return Operation.response_model().model_validate(
+                    response, **model_validate_options
+                )
+            except ValidationError as e:
+                raise ResponseValidationException(
+                    operation_name=Operation.__name__,
+                    response=response,
+                    pydantic_error=str(e),
+                ) from e
 
         @staticmethod
         def request_method() -> HttpMethods:
@@ -204,81 +303,3 @@ def build_api_operation(
             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__":
-    # Example models
-    class GetUserPathParams(BaseModel):
-        """Path parameters for the user endpoint."""
-
-        user_id: int
-
-    class GetUserRequestBody(BaseModel):
-        """Request body/query parameters for the user endpoint."""
-
-        include_profile: bool = False
-
-    class UserResponse(BaseModel):
-        """Response model for user data."""
-
-        id: int
-        name: str
-
-    # Example usage of make_endpoint_class
-    UserOperation = build_endpoint_class(
-        url_template=Template("/users/${user_id}"),
-        path_params_constructor=GetUserPathParams,
-        payload_constructor=GetUserRequestBody,
-        response_model_type=UserResponse,
-        method=EndpointMethods.GET,
-    )
-
-    # Create URL from path parameters
-    url = UserOperation.create_url(user_id=123)
-    print(f"URL: {url}")
-
-    # Create payload from request body parameters
-    payload = UserOperation.create_payload(include_profile=True)
-    print(f"Payload: {payload}")
-
-    # Create response from endpoint
-    response = UserOperation.handle_response(
-        {
-            "id": 123,
-            "name": "John Doe",
-        }
-    )
-    print(f"Response: {response}")