waldiez 0.4.6__py3-none-any.whl → 0.4.8__py3-none-any.whl

waldiez/io/models/content/video.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=unused-argument
+"""Video and audio media content models."""
+
+from pathlib import Path
+
+from pydantic import BaseModel
+from typing_extensions import Literal
+
+from .base import VideoContent
+
+
+class VideoMediaContent(BaseModel):
+    """Video media content."""
+
+    type: Literal["video"] = "video"
+    video: VideoContent
+
+    def to_string(
+        self,
+        uploads_root: Path | None,
+        base_name: str | None = None,
+    ) -> str:
+        """Convert the content to a string.
+
+        Parameters
+        ----------
+        uploads_root : Path | None
+            The root directory for storing images, optional.
+        base_name : str | None
+            The base name for the image file, optional.
+
+        Returns
+        -------
+        str
+            The string representation of the content.
+        """
+        if self.video.url:
+            return f"<video src='{self.video.url}'></video>"
+        if self.video.file:
+            return f"<video src='{self.video.file}'></video>"
+        return str(self.video.file)

waldiez/io/models/user_input.py

@@ -0,0 +1,269 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+"""User input data models and validation."""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Union
+from urllib.parse import urlparse
+
+from pydantic import BaseModel, Field, field_validator
+from typing_extensions import Annotated
+
+from ..utils import detect_media_type
+from .constants import CONTENT_MAPPING, ContentMappingEntry, MediaContent
+from .content.audio import AudioMediaContent
+from .content.base import (
+    AudioContent,
+    FileContent,
+    ImageContent,
+    VideoContent,
+)
+from .content.file import FileMediaContent
+from .content.image import ImageMediaContent, ImageUrlMediaContent
+from .content.text import TextMediaContent
+from .content.video import VideoMediaContent
+
+
+class UserInputData(BaseModel):
+    """User's input data model."""
+
+    content: Annotated[
+        Union[MediaContent, list[MediaContent]],
+        Field(
+            description="The content of the input data.",
+            title="Content",
+        ),
+    ]
+
+    def __str__(self) -> str:
+        """Get the string representation of the content."""
+        return self.to_string()
+
+    def __repr__(self) -> str:
+        """Get the string representation of the UserInputData."""
+        return f"UserInputData(content={self.to_string()})"
+
+    def to_string(
+        self,
+        uploads_root: Path | None = None,
+        base_name: str | None = None,
+    ) -> str:
+        """Convert the content to a string.
+
+        Parameters
+        ----------
+        uploads_root : Path | None
+            The root directory for storing images, optional.
+        base_name : str | None
+            The base name for the image file, optional.
+
+        Returns
+        -------
+        str
+            The string representation of the content.
+        """
+        if isinstance(self.content, list):
+            return " ".join(
+                [
+                    item.to_string(uploads_root, base_name)  # pyright: ignore
+                    for item in self.content
+                ]
+            )
+        return self.content.to_string(uploads_root, base_name)
+
+    @classmethod
+    def content_from_string(cls, value: str) -> MediaContent:
+        """Convert a string to the appropriate MediaContent type.
+
+        Parameters
+        ----------
+        value : str
+            The input string
+
+        Returns
+        -------
+        MediaContent
+            the appropriate MediaContent.
+        """
+        try:
+            parsed = json.loads(value)
+        except json.JSONDecodeError:
+            return TextMediaContent(type="text", text=value)
+        if isinstance(parsed, str):
+            try:
+                parsed = json.loads(parsed)
+            except json.JSONDecodeError:
+                return TextMediaContent(type="text", text=parsed)
+            if isinstance(parsed, str):
+                return TextMediaContent(type="text", text=parsed)
+        return cls.validate_content(parsed)
+
+    @classmethod
+    def content_from_dict(cls, value: dict[str, Any]) -> MediaContent:
+        """Convert a dictionary to the appropriate MediaContent type.
+
+        Parameters
+        ----------
+        value : dict[str, Any]
+            The input dictionary
+
+        Returns
+        -------
+        MediaContent
+            the appropriate MediaContent.
+
+        Raises
+        ------
+        ValueError
+            If the content type is not supported or
+            if any required field is missing.
+        """
+        content_type = detect_media_type(value)
+
+        # Get the mapping for the detected content type
+        if content_type not in CONTENT_MAPPING:
+            raise ValueError(f"Unsupported content type: {content_type}")
+
+        # Get the mapping for the content type
+        mapping = CONTENT_MAPPING[content_type]
+        return cls._build_media_content(value, mapping, content_type)
+
+    @classmethod
+    def _build_media_content(
+        cls,
+        value: dict[str, Any],
+        mapping: ContentMappingEntry,
+        content_type: str,
+    ) -> MediaContent:
+        """Try to construct the appropriate MediaContent from the mapping."""
+        for field in mapping["fields"]:
+            if field not in value:
+                continue
+
+            raw_val = value[field]
+
+            if field == mapping["required_field"]:
+                # if we have direct mapping to the required field,
+                # let's try to instantiate the class directly
+                try:
+                    return mapping["cls"](**{field: raw_val})
+                except ValueError:
+                    pass  # let's try to convert it
+
+            converted = cls._convert_simple_content(
+                raw_val, mapping["required_field"]
+            )
+            if converted is not None:  # pragma: no branch
+                return mapping["cls"](
+                    **{mapping["required_field"]: converted}  # type: ignore
+                )
+
+        raise ValueError(
+            "Missing required field for content type "
+            f"'{content_type}' in: {value}"
+        )
+
+    @staticmethod
+    def _convert_simple_content(
+        raw_val: Any, target_field: str
+    ) -> ImageContent | VideoContent | AudioContent | FileContent | None:
+        """Convert a simple string to the appropriate content, if applicable."""
+        if not isinstance(raw_val, str):  # pragma: no cover
+            return None
+
+        if target_field in ("image_url", "image"):
+            return ImageContent(url=raw_val)
+        if target_field == "video":
+            return VideoContent(url=raw_val)
+        if target_field == "audio":
+            return AudioContent(url=raw_val)
+        if target_field == "file":
+            filename = extract_filename_from_path(raw_val)
+            return FileContent(name=filename, url=raw_val)
+
+        return None  # pragma: no cover
+
+    @field_validator("content", mode="before")
+    @classmethod
+    def validate_content(cls, v: Any) -> MediaContent:  # noqa: C901,D102
+        """Validate the input data content.
+
+        Parameters
+        ----------
+        v: Any
+            The input data content
+
+        Returns
+        -------
+        MediaContent
+            The validated content
+
+        Raises
+        ------
+        ValueError
+            If the content is not valid.
+        """
+        if isinstance(
+            v,
+            (
+                TextMediaContent,
+                ImageMediaContent,
+                ImageUrlMediaContent,
+                VideoMediaContent,
+                AudioMediaContent,
+                FileMediaContent,
+            ),
+        ):
+            return v
+
+        # If it's a string, check if it is a dumped one
+        if isinstance(v, str):
+            return cls.content_from_string(v)
+
+        # If it's a dictionary, check if it has a 'type' field
+        if isinstance(v, dict):
+            return cls.content_from_dict(v)  # pyright: ignore
+
+        # If it's a list
+        if isinstance(v, list):
+            return [cls.validate_content(item) for item in v]  # type: ignore
+
+        # Default fallback
+        return TextMediaContent(type="text", text=str(v))
+
+
+def extract_filename_from_path(path_or_url: str) -> str:
+    """Extract the filename from a given path or URL.
+
+    Parameters
+    ----------
+    path_or_url: str
+        The path or URL from which to extract the filename.
+
+    Returns
+    -------
+    str
+        The extracted filename.
+    """
+    if "://" in path_or_url:
+        # It's a URL - parse it properly
+        parsed = urlparse(path_or_url)
+        # Extract filename from the path component
+        filename = os.path.basename(parsed.path)
+
+        # Handle edge cases where path might be empty or end with /
+        if not filename and parsed.path.endswith("/"):
+            # Try to get the last directory name
+            path_parts = [p for p in parsed.path.split("/") if p]
+            filename = path_parts[-1] if path_parts else parsed.netloc
+        elif not filename:
+            # Fallback to using netloc (domain) if no path
+            filename = parsed.netloc
+
+        return filename
+    # else:
+    # Local file path
+    return os.path.basename(path_or_url)

waldiez/io/models/user_response.py

@@ -0,0 +1,215 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""User response model and validation."""
+
+import json
+from pathlib import Path
+from typing import Any, Callable, Optional, Union
+
+from pydantic import ValidationError, field_validator
+
+from ..utils import MessageType
+from .base import StructuredBase
+from .content.text import TextMediaContent
+from .user_input import UserInputData
+
+
+class UserResponse(StructuredBase):
+    """User response model."""
+
+    request_id: str
+    type: MessageType = "input_response"
+    data: UserInputData | list[UserInputData] | str
+
+    @field_validator("data", mode="before")
+    @classmethod
+    def validate_data(
+        cls, value: Any
+    ) -> Optional[Union[str, UserInputData, list[UserInputData]]]:
+        """Validate the data field in UserResponse.
+
+        Parameters
+        ----------
+        value : Any
+            The value to validate.
+
+        Returns
+        -------
+        Union[str, UserInputData, list[UserInputData]]
+            The validated value.
+
+        Raises
+        ------
+        ValueError
+            If the value is not valid.
+        """
+        if value is None:
+            return ""
+        if cls._is_valid_type(value):
+            return value
+
+        handlers: dict[
+            type,
+            Callable[[Any], Union[str, UserInputData, list[UserInputData]]],
+        ] = {
+            str: cls._handle_string,
+            dict: cls._handle_dict,
+            list: cls._handle_list,
+        }
+
+        value_type = type(value)  # pyright: ignore
+        handler = handlers.get(
+            value_type,  # pyright: ignore
+            cls._handle_default,
+        )
+        result = handler(value)
+        return result
+
+    @classmethod
+    def _is_valid_type(cls, value: Any) -> bool:
+        """Check if value is already a valid type."""
+        return isinstance(value, UserInputData) or (
+            isinstance(value, list)
+            and all(
+                isinstance(item, UserInputData)
+                for item in value  # pyright: ignore
+            )
+        )
+
+    @classmethod
+    def _handle_string(
+        cls, value: str
+    ) -> Union[str, UserInputData, list[UserInputData]]:
+        """Handle string input.
+
+        Parameters
+        ----------
+        value : str
+            The string value to handle.
+
+        Returns
+        -------
+        Union[str, UserInputData, list[UserInputData]]
+            The handled value.
+        """
+        # pylint: disable=too-many-try-statements
+        try:
+            parsed_value = json.loads(value)
+            if isinstance(parsed_value, dict):
+                return cls._handle_dict(parsed_value)  # pyright: ignore
+            if isinstance(parsed_value, list):
+                return cls._handle_list(parsed_value)  # pyright: ignore
+            return cls._create_text_input(str(parsed_value))
+        except json.JSONDecodeError:
+            return cls._create_text_input(value)
+
+    @classmethod
+    def _handle_dict(cls, value: dict[str, Any]) -> UserInputData:
+        if "content" in value:
+            return cls._try_parse_user_input(value)
+
+        try:
+            return UserInputData(content=value)  # type: ignore
+        except (ValueError, TypeError, ValidationError):
+            return cls._create_invalid_input(value, label="Invalid data")
+
+    @classmethod
+    def _try_parse_user_input(cls, value: dict[str, Any]) -> UserInputData:
+        try:
+            return UserInputData(content=value["content"])
+        except (KeyError, ValueError, TypeError, ValidationError):
+            try:
+                return UserInputData(content=value)  # type: ignore
+            except (ValueError, TypeError, ValidationError):
+                return cls._create_invalid_input(value, label="Invalid content")
+
+    @classmethod
+    def _handle_list(
+        cls, value: list[Any]
+    ) -> Union[UserInputData, list[UserInputData]]:
+        result: list[UserInputData] = []
+
+        for item in value:
+            if isinstance(item, UserInputData):
+                result.append(item)
+            elif isinstance(item, dict):
+                result.append(cls._handle_dict(item))  # pyright: ignore
+            elif isinstance(item, str):
+                result.append(cls._create_text_input(item))
+            elif isinstance(item, list):
+                nested_result = cls._handle_list(item)  # pyright: ignore
+                if isinstance(nested_result, list):
+                    result.extend(nested_result)
+                else:
+                    result.append(nested_result)
+            else:
+                result.append(cls._create_text_input(str(item)))
+
+        return result[0] if len(result) == 1 else result
+
+    @classmethod
+    def _handle_default(cls, value: Any) -> UserInputData:
+        return cls._create_text_input(str(value))
+
+    @classmethod
+    def _create_text_input(cls, text: str) -> UserInputData:
+        return UserInputData(content=TextMediaContent(text=text))
+
+    @classmethod
+    def _create_invalid_input(cls, raw: Any, label: str) -> UserInputData:
+        try:
+            preview = json.dumps(raw)[:100]
+        except (TypeError, ValueError):  # pragma: no cover
+            preview = str(raw)[:100]
+        return UserInputData(
+            content=TextMediaContent(text=f"{label}: {preview}...")
+        )
+
+    def to_string(
+        self,
+        uploads_root: Path | None = None,
+        base_name: str | None = None,
+    ) -> str:
+        """Convert the UserResponse to a string.
+
+        Parameters
+        ----------
+        uploads_root : Path | None
+            The root directory for storing images, optional.
+        base_name : str | None
+            The base name for the image file, optional.
+
+        Returns
+        -------
+        str
+            The string representation of the UserResponse.
+        """
+        if isinstance(self.data, list):
+            return " ".join(
+                [
+                    (
+                        item.to_string(
+                            uploads_root=uploads_root, base_name=base_name
+                        )
+                        if hasattr(item, "to_string")
+                        else (
+                            item
+                            if isinstance(item, str)  # pragma: no cover
+                            else str(item)
+                        )  # pragma: no cover
+                    )
+                    for item in self.data
+                ]
+            ).strip()
+        if isinstance(self.data, UserInputData):
+            return self.data.to_string(
+                uploads_root=uploads_root, base_name=base_name
+            ).strip()
+        # we have probably returned sth till here
+        if isinstance(self.data, str):  # pyright: ignore # pragma: no cover
+            return self.data
+        return (  # pragma: no cover
+            json.dumps(self.data)
+            if hasattr(self.data, "__dict__")
+            else str(self.data)
+        )