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

waldiez/models/chat/chat_summary.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez chat summary options."""
 
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from pydantic import (
     Field,
@@ -32,35 +32,36 @@ class WaldiezChatSummary(WaldiezBase):
         The method to use for the LLM summary. Defaults to "last_msg".
     prompt : str
         The prompt for the LLM summary method.
-    args : Optional[Dict[str, Any]]
+    args : Optional[dict[str, Any]]
         The additional arguments for the LLM summary method, by default None.
     """
 
     method: Annotated[
         Optional[WaldiezChatSummaryMethod],
         Field(
-            "last_msg",
+            default="last_msg",
             title="Method",
             description="The method to use for the LLM summary.",
         ),
-    ]
+    ] = "last_msg"
     prompt: Annotated[
         str,
         Field(
-            "",
+            default="Summarize the conversation.",
             title="Prompt",
             description="The prompt for the LLM summary method.",
         ),
-    ]
+    ] = "Summarize the conversation."
     args: Annotated[
-        Dict[str, str],
+        dict[str, str],
         Field(
             title="Arguments",
             description="The additional arguments for the LLM summary method.",
             default_factory=dict,
         ),
-    ]
+    ] = {}
 
+    # noinspection PyNestedDecorators
     @field_validator("method", mode="before")
     @classmethod
     def validate_summary_method(
@@ -86,6 +87,7 @@ class WaldiezChatSummary(WaldiezBase):
             return "reflection_with_llm"
         return value
 
+    # noinspection PyNestedDecorators
     @field_serializer("method")
     @classmethod
     def serialize_summary_method(

waldiez/models/common/__init__.py

@@ -6,6 +6,27 @@ from .ag2_version import get_autogen_version
 from .base import WaldiezBase
 from .date_utils import now
 from .dict_utils import update_dict
+from .handoff import (
+    WaldiezAgentTarget,
+    WaldiezContextBasedCondition,
+    WaldiezContextBasedTransition,
+    WaldiezContextStrLLMCondition,
+    WaldiezDefaultCondition,
+    WaldiezExpressionContextCondition,
+    WaldiezGroupOrNestedTarget,
+    WaldiezHandoff,
+    WaldiezHandoffCondition,
+    WaldiezHandoffTransition,
+    WaldiezLLMBasedCondition,
+    WaldiezLLMBasedTransition,
+    WaldiezRandomAgentTarget,
+    WaldiezSimpleTarget,
+    WaldiezStringContextCondition,
+    WaldiezStringLLMCondition,
+    WaldiezTransitionAvailability,
+    WaldiezTransitionTarget,
+)
+from .id_generator import get_id
 from .method_utils import (
     check_function,
     gather_code_imports,
@@ -13,15 +34,44 @@ from .method_utils import (
     get_function,
     parse_code_string,
 )
+from .naming import (
+    MAX_VARIABLE_LENGTH,
+    get_valid_instance_name,
+    get_valid_python_variable_name,
+)
+from .waldiez_version import get_waldiez_version
 
 __all__ = [
+    "MAX_VARIABLE_LENGTH",
     "WaldiezBase",
-    "now",
     "check_function",
+    "update_dict",
     "gather_code_imports",
     "get_autogen_version",
     "get_function",
+    "get_id",
+    "get_valid_instance_name",
+    "get_valid_python_variable_name",
+    "get_waldiez_version",
     "generate_function",
+    "now",
     "parse_code_string",
-    "update_dict",
+    "WaldiezDefaultCondition",
+    "WaldiezAgentTarget",
+    "WaldiezContextBasedCondition",
+    "WaldiezContextBasedTransition",
+    "WaldiezContextStrLLMCondition",
+    "WaldiezExpressionContextCondition",
+    "WaldiezGroupOrNestedTarget",
+    "WaldiezHandoff",
+    "WaldiezHandoffCondition",
+    "WaldiezHandoffTransition",
+    "WaldiezLLMBasedCondition",
+    "WaldiezLLMBasedTransition",
+    "WaldiezRandomAgentTarget",
+    "WaldiezSimpleTarget",
+    "WaldiezStringContextCondition",
+    "WaldiezStringLLMCondition",
+    "WaldiezTransitionAvailability",
+    "WaldiezTransitionTarget",
 ]

waldiez/models/common/ag2_version.py

@@ -27,4 +27,4 @@ def get_autogen_version() -> str:
             from autogen.version import __version__ as ag2  # type: ignore
         except ImportError as error:  # pragma: no cover
             raise ValueError("ag2 is not installed.") from error
-    return ag2
+        return ag2

waldiez/models/common/base.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Base class to inherit from."""
 
-from typing import Any, Dict
+from typing import Any
 
 from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
@@ -17,15 +17,15 @@ class WaldiezBase(BaseModel):
 
     model_config = ConfigDict(
         extra="ignore",
-        # treat `skillId` as `skill_id`
+        # treat `toolId` as `tool_id`
         alias_generator=to_camel,
-        # allow passing either `skill_id` or `skillId`
+        # allow passing either `tool_id` or `toolId`
         populate_by_name=True,
         # allow setting any attribute after initialization
         frozen=False,
     )
 
-    def model_dump(self, **kwargs: Any) -> Dict[str, Any]:
+    def model_dump(self, **kwargs: Any) -> dict[str, Any]:
         """Dump the model to a dictionary.
 
         Parameters
@@ -33,17 +33,34 @@ class WaldiezBase(BaseModel):
         **kwargs : Any
             Additional keyword arguments.
 
+            The following are from the Pydantic `model_dump` method:
+              - mode: str | Literal['json', 'python'] = 'json',
+              - include: IncEx | None
+              - exclude: IncEx | None
+              - context: Any | None
+              - by_alias: bool | None (None defaults to True)
+              - exclude_unset: bool = False
+              - exclude_defaults: bool = False
+              - exclude_none: bool = False
+              - round_trip: bool = False
+              - warnings: bool | Literal['none', 'warn', 'error'] = True
+              - fallback: ((Any) -> Any) | None = None
+              - serialize_as_any: bool = False
+
         Returns
         -------
-        Dict[str, Any]
+        dict[str, Any]
             The dictionary representation of the model.
         """
         by_alias = kwargs.pop("by_alias", None)
-        if by_alias is None:
+        mode = kwargs.pop("mode", None)
+        if mode is None:  # pragma: no branch
+            mode = "json"
+        if by_alias is None:  # pragma: no branch
             by_alias = True
         if not isinstance(by_alias, bool):
             by_alias = True
-        return super().model_dump(by_alias=by_alias, **kwargs)
+        return super().model_dump(by_alias=by_alias, mode=mode, **kwargs)
 
     def model_dump_json(self, **kwargs: Any) -> str:
         """Dump the model to a JSON string.
@@ -53,6 +70,20 @@ class WaldiezBase(BaseModel):
         **kwargs : Any
             Additional keyword arguments.
 
+            The following are from the Pydantic `model_dump_json` method:
+            - indent: int | None = None,
+            - include: IncEx | None = None,
+            - exclude: IncEx | None = None,
+            - context: Any | None = None,
+            - by_alias: bool | None = None, (None defaults to True)
+            - exclude_unset: bool = False,
+            - exclude_defaults: bool = False,
+            - exclude_none: bool = False,
+            - round_trip: bool = False,
+            - warnings: bool | Literal['none', 'warn', 'error'] = True,
+            - fallback: ((Any) -> Any) | None = None,
+            - serialize_as_any: bool = False
+
         Returns
         -------
         str

waldiez/models/common/dict_utils.py

@@ -2,38 +2,63 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Dictionary related utilities."""
 
-from typing import Any, Dict
+import re
+from typing import Any
 
+BOOL_VALUES = {"true", "false"}
+NULL_VALUES = {"none", "null", "nil", "undefined"}
 
-def update_dict(original: Dict[str, Any]) -> Dict[str, Any]:
-    """
 
+def update_dict(original: dict[str, Any]) -> dict[str, Any]:
+    """
     Try to determine the type of the dictionary values.
 
     Parameters
     ----------
-    original : Dict[str, Any]
+    original : dict[str, Any]
         The original dictionary.
 
     Returns
     -------
-    Dict[str, Any]
+    dict[str, Any]
         The updated dictionary with values converted to the detected types.
     """
-    new_dict: Dict[str, Any] = {}
+    new_dict: dict[str, Any] = {}
+
     for key, value in original.items():
-        value_lower = str(value).lower()
-        if value_lower in ("none", "null"):
+        # 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
-        elif value_lower in ("true", "false"):
+        # Check for boolean
+        elif value_lower in BOOL_VALUES:
             new_dict[key] = value_lower == "true"
-        elif str(value).isdigit():
-            new_dict[key] = int(value)
-        elif str(value).replace(".", "").isdigit():
-            try:
-                new_dict[key] = float(value)
-            except ValueError:  # pragma: no cover
-                new_dict[key] = value
+        # Check for integer
+        elif re.fullmatch(r"[-+]?\d+", value_stripped):
+            new_dict[key] = int(value_stripped)
+        # Check for float
         else:
-            new_dict[key] = value
+            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