waldiez 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

waldiez/logger.py

@@ -4,6 +4,7 @@
 """Waldiez logger."""
 
 import inspect
+import logging
 import os
 import re
 import string
@@ -11,23 +12,27 @@ import threading
 import traceback
 from datetime import datetime
 from enum import IntEnum
-from typing import Any, Callable, Optional
+from pathlib import Path
+from types import TracebackType
+from typing import Any, Callable, Mapping, Optional
 
 import click
 
+HERE = Path(__file__).parent
+
 
 class LogLevel(IntEnum):
     """Log level enumeration for comparison."""
 
     DEBUG = 10
     INFO = 20
-    SUCCESS = 30
-    WARNING = 40
-    ERROR = 50
-    CRITICAL = 60
+    SUCCESS = 21
+    WARNING = 30
+    ERROR = 40
+    CRITICAL = 50
 
 
-class WaldiezLogger:
+class WaldiezLogger(logging.Logger):
     """A colorful logger implementation using Click.
 
     Supports both .format() and %-style formatting:
@@ -51,9 +56,29 @@ class WaldiezLogger:
         "critical",
         "exception",
     }
+    _level_map: dict[str, LogLevel] = {
+        "DEBUG": LogLevel.DEBUG,
+        "INFO": LogLevel.INFO,
+        "SUCCESS": LogLevel.SUCCESS,
+        "WARNING": LogLevel.WARNING,
+        "ERROR": LogLevel.ERROR,
+        "CRITICAL": LogLevel.CRITICAL,
+    }
+    # Map levels to click styling functions
+    _style_map: dict[str, Callable[[str], str]] = {
+        "DEBUG": lambda msg: click.style(msg, dim=True),
+        "INFO": lambda msg: click.style(msg, fg="blue"),
+        "SUCCESS": lambda msg: click.style(msg, fg="green"),
+        "WARNING": lambda msg: click.style(msg, fg="yellow"),
+        "ERROR": lambda msg: click.style(msg, fg="red"),
+        "CRITICAL": lambda msg: click.style(msg, fg="red", bold=True),
+        "EXCEPTION": lambda msg: click.style(msg, fg="red", bold=True),
+    }
 
     def __new__(cls, *args: Any, **kwargs: Any) -> "WaldiezLogger":
         """Ensure only one instance of the logger is created."""
+        for level_name, level_value in LogLevel.__members__.items():
+            logging.addLevelName(level_value, level_name)
         if cls._instance is None:
             with cls._lock:
                 # Double-check locking pattern
@@ -75,6 +100,9 @@ class WaldiezLogger:
         timestamp_format : str, optional
             Timestamp format string, by default "%Y-%m-%d %H:%M:%S"
         """
+        super().__init__(self.__class__.__name__)
+        for level_name, level_value in LogLevel.__members__.items():
+            logging.addLevelName(level_value, level_name)
         if getattr(self, "_initialized", False) is True:
             if level != self.get_level():
                 self.set_level(level)
@@ -84,29 +112,16 @@ class WaldiezLogger:
             ):
                 self._instance.set_timestamp_format(timestamp_format)
             return
+        self._initialized = True
         self._level = level.upper()
         self._timestamp_format = timestamp_format
-
-        self._level_map: dict[str, LogLevel] = {
-            "DEBUG": LogLevel.DEBUG,
-            "INFO": LogLevel.INFO,
-            "SUCCESS": LogLevel.SUCCESS,
-            "WARNING": LogLevel.WARNING,
-            "ERROR": LogLevel.ERROR,
-            "CRITICAL": LogLevel.CRITICAL,
-        }
-
-        # Map levels to click styling functions
-        self._style_map: dict[str, Callable[[str], str]] = {
-            "DEBUG": lambda msg: click.style(msg, dim=True),
-            "INFO": lambda msg: click.style(msg, fg="blue"),
-            "SUCCESS": lambda msg: click.style(msg, fg="green"),
-            "WARNING": lambda msg: click.style(msg, fg="yellow"),
-            "ERROR": lambda msg: click.style(msg, fg="red"),
-            "CRITICAL": lambda msg: click.style(msg, fg="red", bold=True),
-            "EXCEPTION": lambda msg: click.style(msg, fg="red", bold=True),
-        }
-        self._initialized = True
+        if self.get_level() != level:
+            self.set_level(level)
+        if (
+            self._instance
+            and self._instance.get_timestamp_format() != timestamp_format
+        ):
+            self._instance.set_timestamp_format(timestamp_format)
 
     @classmethod
     def get_instance(
@@ -130,129 +145,207 @@ class WaldiezLogger:
         """
         return cls(level, timestamp_format)
 
+    def _get_level_name(self, level: int) -> str:
+        """Get the string name of the logging level.
+
+        Parameters
+        ----------
+        level : int
+            The logging level.
+
+        Returns
+        -------
+        str
+            The string name of the logging level.
+        """
+        for name, lvl in self._level_map.items():
+            if lvl == level:
+                return name
+        return self.get_level()
+
+    def _get_level_number(self, level: str) -> int:
+        """Get the numeric value of the logging level.
+
+        Parameters
+        ----------
+        level : str
+            The logging level.
+
+        Returns
+        -------
+        int
+            The numeric value of the logging level.
+        """
+        return self._level_map.get(level.upper(), LogLevel.INFO)
+
+    # pylint: disable=unused-argument
     def log(
-        self, message: Any, *args: Any, level: str = "info", **kwargs: Any
+        self,
+        level: int,
+        msg: object,
+        *args: object,
+        exc_info: (
+            bool
+            | tuple[type[BaseException], BaseException, TracebackType | None]
+            | tuple[None, None, None]
+            | BaseException
+            | None
+        ) = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None:
         """Log a message with the specified level.
 
         Parameters
         ----------
-        message : Any
+        level : int
+            The logging level to use (e.g., logging.DEBUG, logging.INFO, etc.).
+        msg : object
             The message to log or message template for formatting.
-        level : str, optional
-            The logging level to use (e.g., "debug", "info", "success",
-            "warning", "error", "critical"). Defaults to "info".
-        *args : Any
-            Arguments to format into the message using % formatting.
-        **kwargs : Any
+        *args : object
+            Arguments to format into the message.
+        exc_info :
+            bool |
+            tuple[type[BaseException], BaseException, TracebackType | None] |
+            tuple[None, None, None] |
+            BaseException |
+            None
+            Exception information to include in the log.
+        stack_info : bool
+            Whether to include stack information in the log.
+        stacklevel : int
+            The stack level to use for the log.
+        extra : Mapping[str, object] | None
+            Extra context information to include in the log.
+        **kwargs : object
             Additional keyword arguments for formatting.
+
         """
-        if self._should_log(level):
-            formatted_message_content = self._format_args(
-                message, *args, **kwargs
-            )
+        level_str = self._get_level_name(level)
+        if self._should_log(level_str):
+            # noinspection PyArgumentList
+            formatted_message_content = self._format_args(msg, *args, **kwargs)
             formatted_message = self._format_message(
-                formatted_message_content, level
+                formatted_message_content, level_str
             )
             click.echo(formatted_message)
 
-    def debug(self, message: Any, *args: Any, **kwargs: Any) -> None:
+    def do_log(self, msg: Any, *args: Any, level: str, **kwargs: Any) -> None:
+        """Log a message with the specified level.
+
+        Parameters
+        ----------
+        msg : Any
+            The message to log or message template for formatting.
+        *args : Any
+            Arguments to format into the message.
+        level : str
+            The logging level.
+        **kwargs : Any
+            Additional keyword arguments for formatting.
+        """
+        level_int = self._get_level_number(level)
+        self.log(level_int, msg, *args, **kwargs)
+
+    def debug(self, msg: Any, *args: Any, **kwargs: Any) -> None:
         """Log a debug message.
 
         Parameters
         ----------
-        message : Any
+        msg : Any
             The debug message to log or message template.
         *args : Any
             Arguments to format into the message.
         **kwargs : Any
             Additional keyword arguments for formatting.
         """
-        self.log(message, *args, level="debug", **kwargs)
+        self.do_log(msg, *args, level="debug", **kwargs)
 
-    def info(self, message: Any, *args: Any, **kwargs: Any) -> None:
+    def info(self, msg: Any, *args: Any, **kwargs: Any) -> None:
         """Log an informational message.
 
         Parameters
         ----------
-        message : Any
+        msg : Any
             The informational message to log or message template.
         *args : Any
             Arguments to format into the message.
         **kwargs : Any
             Additional keyword arguments for formatting.
         """
-        self.log(message, *args, level="info", **kwargs)
+        self.do_log(msg, *args, level="info", **kwargs)
 
-    def success(self, message: Any, *args: Any, **kwargs: Any) -> None:
+    def success(self, msg: Any, *args: Any, **kwargs: Any) -> None:
         """Log a success message.
 
         Parameters
         ----------
-        message : Any
+        msg : Any
             The success message to log or message template.
         *args : Any
             Arguments to format into the message.
         **kwargs : Any
             Additional keyword arguments for formatting.
         """
-        self.log(message, *args, level="success", **kwargs)
+        self.do_log(msg, *args, level="success", **kwargs)
 
-    def warning(self, message: Any, *args: Any, **kwargs: Any) -> None:
+    def warning(self, msg: Any, *args: Any, **kwargs: Any) -> None:
         """Log a warning message.
 
         Parameters
         ----------
-        message : Any
+        msg : Any
             The warning message to log or message template.
         *args : Any
             Arguments to format into the message.
         **kwargs : Any
             Additional keyword arguments for formatting.
         """
-        self.log(message, *args, level="warning", **kwargs)
+        self.do_log(msg, *args, level="warning", **kwargs)
 
-    def error(self, message: Any, *args: Any, **kwargs: Any) -> None:
+    def error(self, msg: Any, *args: Any, **kwargs: Any) -> None:
         """Log an error message.
 
         Parameters
         ----------
-        message : Any
+        msg : Any
             The error message to log or message template.
         *args : Any
             Arguments to format into the message.
         **kwargs : Any
             Additional keyword arguments for formatting.
         """
-        self.log(message, *args, level="error", **kwargs)
+        self.do_log(msg, *args, level="error", **kwargs)
 
-    def critical(self, message: Any, *args: Any, **kwargs: Any) -> None:
+    def critical(self, msg: Any, *args: Any, **kwargs: Any) -> None:
         """Log a critical error message.
 
         Parameters
         ----------
-        message : Any
+        msg : Any
             The critical error message to log or message template.
         *args : Any
             Arguments to format into the message.
         **kwargs : Any
             Additional keyword arguments for formatting.
         """
-        self.log(message, *args, level="critical", **kwargs)
+        self.do_log(msg, *args, level="critical", **kwargs)
 
-    def exception(self, message: Any, *args: Any, **kwargs: Any) -> None:
+    def exception(self, msg: Any, *args: Any, **kwargs: Any) -> None:
         """Log an exception message.
 
         Parameters
         ----------
-        message : Any
+        msg : Any
             The exception message to log or message template.
         *args : Any
             Arguments to format into the message.
         **kwargs : Any
             Additional keyword arguments for formatting.
         """
-        formatted_message_content = self._format_args(message, *args, **kwargs)
+        formatted_message_content = self._format_args(msg, *args, **kwargs)
         formatted_message = self._format_message(
             formatted_message_content, "exception"
         )
@@ -261,6 +354,21 @@ class WaldiezLogger:
         if tb and "NoneType: None" not in tb:  # pragma: no branch
             click.echo(click.style(tb, fg="red", dim=True))
 
+    def setLevel(self, level: int | str) -> None:
+        """
+        Set the logging level.
+
+        Parameters
+        ----------
+        level : int | str
+            The logging level to set
+            (e.g., "debug", "info", "warning", "error", "critical").
+        """
+        level_str = (
+            level if isinstance(level, str) else self._get_level_name(level)
+        )
+        self.set_level(level_str)
+
     def set_level(self, level: str) -> None:
         """Set the logging level.
 
@@ -278,6 +386,7 @@ class WaldiezLogger:
         level_upper = level.upper()
         if level_upper in self._level_map:
             self._level = level_upper
+            super().setLevel(self._level_map[level_upper].value)
         else:
             raise ValueError(
                 f"Invalid log level: {level}. "
@@ -369,8 +478,15 @@ class WaldiezLogger:
     @staticmethod
     def _format_caller_display(filename: str, line_number: int) -> str:
         """Format the caller information for display."""
-        basename = os.path.realpath(filename)
-        return f"{basename}:{line_number}"
+        full_path = Path(filename).resolve()
+        try:
+            relative = full_path.relative_to(Path.cwd())
+        except ValueError:  # pragma: no cover
+            try:
+                relative = full_path.relative_to(HERE.parent)
+            except ValueError:  # pragma: no cover
+                relative = full_path
+        return f"{relative}:{line_number}"
 
     def _get_timestamp(self) -> str:
         """Get the current timestamp in a human-readable format."""
@@ -400,6 +516,7 @@ class WaldiezLogger:
     ) -> tuple[bool, Any]:
         """Attempt .format() formatting, returning (success, result)."""
         try:
+            # noinspection StrFormat
             return True, msg_str.format(*args, **kwargs)
         except Exception as e:
             return False, e

waldiez/models/agents/agent/update_system_message.py

@@ -1,7 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Update the agent's system message before they reply."""
 
 from typing import Optional

waldiez/models/agents/doc_agent/doc_agent.py

@@ -114,7 +114,14 @@ class WaldiezDocAgent(WaldiezAgent):
         requirements = {
             "llama-index",
             "llama-index-core",
-            f"ag2[rag]=={ag2_version}",
+            # f"ag2[rag]=={ag2_version}",
+            "chromadb>=0.5,<2",
+            "docling>=2.15.1,<3",
+            "selenium>=4.28.1,<5",
+            "webdriver-manager==4.0.2",
+            "llama-index-embeddings-huggingface",
+            "llama-index-llms-langchain",
+            "llama-index-vector-stores-chroma",
         }
         if not self.data.model_ids:
             requirements.add("llama-index-llms-openai")

waldiez/models/common/dict_utils.py

@@ -2,63 +2,192 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Dictionary related utilities."""
 
+import ast
+import json
 import re
-from typing import Any
+from typing import Any, Union
 
 BOOL_VALUES = {"true", "false"}
 NULL_VALUES = {"none", "null", "nil", "undefined"}
 
 
+def _strip_outer_quotes(value: str) -> str:
+    """Remove outer quotes from a string if present."""
+    value_stripped = value.strip()
+    if (value_stripped.startswith('"') and value_stripped.endswith('"')) or (
+        value_stripped.startswith("'") and value_stripped.endswith("'")
+    ):
+        return value_stripped[1:-1]
+    return value_stripped
+
+
+def _detect_null_or_boolean(value: str) -> Union[None, bool, str]:
+    """
+    Detect null values or booleans.
+
+    Parameters
+    ----------
+    value : str
+        The string value to check.
+
+    Returns
+    -------
+    Union[None, bool, str]
+        None for null values, bool for booleans, or original string if neither.
+    """
+    value_lower = value.lower()
+
+    if value_lower in NULL_VALUES:
+        return None
+    if value_lower in BOOL_VALUES:
+        return value_lower == "true"
+
+    return value
+
+
+def _detect_numeric_type(value: str) -> Union[int, float, str]:
+    """
+    Detect if string represents an integer or float.
+
+    Parameters
+    ----------
+    value : str
+        The string value to check.
+
+    Returns
+    -------
+    Union[int, float, str]
+        int for integers, float for floats, or original string if neither.
+    """
+    # Check for integer first (more specific)
+    if re.fullmatch(r"[-+]?\d+", value):
+        return int(value)
+
+    # Try float conversion
+    try:
+        return float(value)
+    except ValueError:
+        return value
+
+
+def _detect_container_type(
+    value: str,
+) -> Union[dict[str, Any], list[Any], tuple[Any], set[Any], str]:
+    """
+    Detect if string represents a container type (dict, list, tuple, set).
+
+    Parameters
+    ----------
+    value : str
+        The string value to check.
+
+    Returns
+    -------
+    Union[dict[str, Any], list[Any], tuple[Any], set[Any], str]
+        Parsed container or original string if not a container.
+    """
+    if not (value[0] in "{[(" and value[-1] in "}])"):
+        return value
+
+    # Handle empty containers
+    if value in ("()", "[]", "{}"):
+        return ast.literal_eval(value)
+
+    # Try JSON first (expects double quotes)
+    try:
+        parsed = json.loads(value)
+        if isinstance(parsed, (dict, list)):
+            return parsed  # pyright: ignore
+    except (json.JSONDecodeError, TypeError):
+        pass
+
+    # Fallback: Python literal (handles single quotes, tuples, sets)
+    try:
+        parsed = ast.literal_eval(value)
+        if isinstance(parsed, (dict, list, tuple, set)):
+            return parsed  # pyright: ignore
+    except (ValueError, SyntaxError):
+        pass
+
+    return value
+
+
+def _convert_string_value(value: str) -> Any:
+    """
+    Convert a string value to its detected type.
+
+    Parameters
+    ----------
+    value : str
+        The string value to convert.
+
+    Returns
+    -------
+    Any
+        The converted value or original string if no conversion possible.
+    """
+    # Strip outer quotes if present
+    cleaned_value = _strip_outer_quotes(value)
+
+    # Skip conversion for empty strings
+    if not cleaned_value:
+        return value
+
+    # Try conversions in order of specificity
+
+    # 1. Container types (most specific structure)
+    container_result = _detect_container_type(cleaned_value)
+    if container_result != cleaned_value:
+        return container_result
+
+    # 2. Null and boolean values
+    null_bool_result = _detect_null_or_boolean(cleaned_value)
+    if null_bool_result != cleaned_value:
+        return null_bool_result
+
+    # 3. Numeric types
+    numeric_result = _detect_numeric_type(cleaned_value)
+    if numeric_result != cleaned_value:
+        return numeric_result
+
+    # 4. Keep as string if no conversion succeeded
+    return cleaned_value
+
+
 def update_dict(original: dict[str, Any]) -> dict[str, Any]:
     """
-    Try to determine the type of the dictionary values.
+    Convert string values in a dictionary to their detected types.
+
+    Automatically detects and converts strings that represent:
+    - Boolean values (true/false)
+    - Null values (none/null/nil/undefined)
+    - Integers and floats
+    - Container types (lists, dicts, tuples, sets)
 
     Parameters
     ----------
     original : dict[str, Any]
-        The original dictionary.
+        The original dictionary with potentially string-encoded values.
 
     Returns
     -------
     dict[str, Any]
-        The updated dictionary with values converted to the detected types.
+        A new dictionary with string values converted to their detected types.
+        Non-string values are preserved unchanged.
+
+    Examples
+    --------
+    >>> data = {"count": "42", "active": "true", "tags": "['a', 'b']"}
+    >>> update_dict(data)
+    {"count": 42, "active": True, "tags": ['a', 'b']}
     """
-    new_dict: dict[str, Any] = {}
+    converted_dict: dict[str, Any] = {}
 
     for key, value in original.items():
-        # Skip conversion if already the desired type
-        if not isinstance(value, str):
-            new_dict[key] = value
-            continue
-
-        value_stripped = value.strip()
-        if (
-            value_stripped.startswith('"') and value_stripped.endswith('"')
-        ) or (value_stripped.startswith("'") and value_stripped.endswith("'")):
-            value_stripped = value_stripped[1:-1]
-        if not value_stripped:  # Empty or whitespace-only
-            new_dict[key] = value
-            continue
-
-        value_lower = value_stripped.lower()
-
-        # Check for None/null
-        if value_lower in NULL_VALUES:
-            new_dict[key] = None
-        # Check for boolean
-        elif value_lower in BOOL_VALUES:
-            new_dict[key] = value_lower == "true"
-        # Check for integer
-        elif re.fullmatch(r"[-+]?\d+", value_stripped):
-            new_dict[key] = int(value_stripped)
-        # Check for float
+        # Only process string values
+        if isinstance(value, str):
+            converted_dict[key] = _convert_string_value(value)
         else:
-            try:
-                # This handles floats, scientific notation, etc.
-                float_val = float(value_stripped)
-                new_dict[key] = float_val
-            except ValueError:
-                # Keep as string if conversion fails
-                new_dict[key] = value_stripped
-
-    return new_dict
+            converted_dict[key] = value
+
+    return converted_dict