ag2 0.9.9__py3-none-any.whl → 0.9.10__py3-none-any.whl

autogen/oai/openai_utils.py

@@ -7,7 +7,6 @@
 
 import importlib
 import importlib.metadata
-import inspect
 import json
 import logging
 import os
@@ -22,6 +21,10 @@ from typing import TYPE_CHECKING, Any, Union
 from dotenv import find_dotenv, load_dotenv
 from packaging.version import parse
 from pydantic_core import to_jsonable_python
+from typing_extensions import deprecated
+
+from ..llm_config.utils import config_list_from_json as latest_config_list_from_json
+from ..llm_config.utils import filter_config as latest_filter
 
 if TYPE_CHECKING:
     from openai import OpenAI
@@ -472,6 +475,11 @@ def config_list_gpt4_gpt35(
 
 
 @export_module("autogen")
+@deprecated(
+    "`autogen.filter_config(...)` is deprecated. "
+    'Please use the "autogen.LLMConfig.from_json(path="OAI_CONFIG_LIST").where(model="gpt-4o")" method instead. '
+    "Scheduled for removal in 0.11.0 version."
+)
 def filter_config(
     config_list: list[dict[str, Any]],
     filter_dict: dict[str, list[str | None] | set[str | None]] | None,
@@ -489,7 +497,9 @@ def filter_config(
 
         filter_dict (dict, optional): A dictionary specifying filter criteria where:
             - Keys are field names to check in each configuration dictionary
-            - Values are lists/sets of acceptable values for that field
+            - Values can be:
+                * a single string value (e.g., {"model": "gpt-4o"})
+                * a list or set of acceptable values for that field (e.g., {"model": ["gpt-4o", "gpt-4o-mini"]})
             - A configuration matches if ALL filter keys are satisfied AND for each key,
               the config's field value matches at least one acceptable value
             - If a filter value includes None, configurations missing that field will match
@@ -517,22 +527,27 @@ def filter_config(
             {"model": "gpt-4", "tags": ["premium", "latest"]},
         ]
 
-        # Example 1: Single criterion - matches any model in the list
+        # Example 1: Single criterion with single string
+        filter_dict = {"model": "gpt-4o"}
+        result = filter_config(configs, filter_dict)
+        # Returns: [{"model": "gpt-4o", "api_type": "openai"}] if present
+
+        # Example 2: Single criterion - matches any model in the list
         filter_dict = {"model": ["gpt-4", "gpt-4o"]}
         result = filter_config(configs, filter_dict)
         # Returns: [{"model": "gpt-4", "api_type": "openai"}, {"model": "gpt-4", "tags": ["premium", "latest"]}]
 
-        # Example 2: Multiple criteria - must satisfy ALL conditions
+        # Example 3: Multiple criteria - must satisfy ALL the conditions
         filter_dict = {"model": ["gpt-3.5-turbo"], "api_type": ["azure"]}
         result = filter_config(configs, filter_dict)
         # Returns: [{"model": "gpt-3.5-turbo", "api_type": "azure", "api_version": "2024-02-01"}]
 
-        # Example 3: Tag filtering with list intersection
+        # Example 4: Tag filtering with list intersection
         filter_dict = {"tags": ["premium"]}
         result = filter_config(configs, filter_dict)
         # Returns: [{"model": "gpt-4", "tags": ["premium", "latest"]}]
 
-        # Example 4: Exclude matching configurations
+        # Example 5: Exclude matching configurations
         filter_dict = {"api_type": ["openai"]}
         result = filter_config(configs, filter_dict, exclude=True)
         # Returns configs that do NOT have api_type="openai"
@@ -543,92 +558,22 @@ def filter_config(
           it is considered a non-match and is excluded from the result.
 
     """
-    if inspect.stack()[1].function != "where":
-        warnings.warn(
-            "filter_config is deprecated and will be removed in a future release. "
-            'Please use the "autogen.LLMConfig.from_json(path="OAI_CONFIG_LIST").where(model="gpt-4o")" method instead.',
-            DeprecationWarning,
-        )
-
-    if filter_dict:
-        return [
-            item
-            for item in config_list
-            if all(_satisfies_criteria(item.get(key), values) != exclude for key, values in filter_dict.items())
-        ]
-    return config_list
-
-
-def _satisfies_criteria(config_value: Any, criteria_values: Any) -> bool:
-    """Check if a configuration field value satisfies the filter criteria.
-
-    This helper function implements the matching logic between a single configuration
-    field value and the acceptable values specified in the filter criteria. It handles
-    both scalar and list-type configuration values with appropriate matching strategies.
-
-    Args:
-        config_value (Any): The value from a configuration dictionary field.
-                           Can be None, a scalar value, or a list of values.
-        criteria_values (Any): The acceptable values from the filter dictionary.
-                              Can be a single value or a list/set of acceptable values.
-
-    Returns:
-        bool: True if the config_value satisfies the criteria, False otherwise.
-
-    Matching Logic:
-        - **None config values**: Always return False (missing fields don't match)
-        - **List config values**:
-            - If criteria is a list: Match if there's any intersection (set overlap)
-            - If criteria is scalar: Match if the scalar is contained in the config list
-        - **Scalar config values**:
-            - If criteria is a list: Match if the config value is in the criteria list
-            - If criteria is scalar: Match if the values are exactly equal
-
-    Examples:
-        ```python
-        # List config value with list criteria (intersection matching)
-        _satisfies_criteria(["gpt-4", "gpt-3.5"], ["gpt-4", "claude"])  # True (gpt-4 intersects)
-        _satisfies_criteria(["tag1", "tag2"], ["tag3", "tag4"])  # False (no intersection)
-
-        # List config value with scalar criteria (containment matching)
-        _satisfies_criteria(["premium", "latest"], "premium")  # True (premium is in list)
-        _satisfies_criteria(["tag1", "tag2"], "tag3")  # False (tag3 not in list)
-
-        # Scalar config value with list criteria (membership matching)
-        _satisfies_criteria("gpt-4", ["gpt-4", "gpt-3.5"])  # True (gpt-4 in criteria)
-        _satisfies_criteria("claude", ["gpt-4", "gpt-3.5"])  # False (claude not in criteria)
-
-        # Scalar config value with scalar criteria (equality matching)
-        _satisfies_criteria("openai", "openai")  # True (exact match)
-        _satisfies_criteria("openai", "azure")  # False (different values)
-
-        # None config values (missing fields)
-        _satisfies_criteria(None, ["gpt-4"])  # False (missing field)
-        _satisfies_criteria(None, "gpt-4")  # False (missing field)
-        ```
+    warnings.warn(
+        "`autogen.filter_config(...)` is deprecated. "
+        'Please use the "autogen.LLMConfig.from_json(path="OAI_CONFIG_LIST").where(model="gpt-4o")" method instead. '
+        "Scheduled for removal in 0.11.0 version.",
+        DeprecationWarning,
+    )
 
-    Note:
-        This is an internal helper function used by `filter_config()`. The function
-        assumes that both parameters can be of various types and handles type
-        checking internally to determine the appropriate matching strategy.
-    """
-    if config_value is None:
-        return False
-
-    if isinstance(config_value, list):
-        if isinstance(criteria_values, list):
-            return bool(set(config_value) & set(criteria_values))  # Non-empty intersection
-        else:
-            return criteria_values in config_value
-    else:
-        # In filter_dict, filter could be either a list of values or a single value.
-        # For example, filter_dict = {"model": ["gpt-3.5-turbo"]} or {"model": "gpt-3.5-turbo"}
-        if isinstance(criteria_values, list):
-            return config_value in criteria_values
-        return bool(config_value == criteria_values)
+    return latest_filter(config_list=config_list, filter_dict=filter_dict, exclude=exclude)
 
 
 @export_module("autogen")
+@deprecated(
+    "`autogen.config_list_from_json(...)` is deprecated. "
+    'Please use the "autogen.LLMConfig.from_json(path="OAI_CONFIG_LIST")" method instead. '
+    "Scheduled for removal in 0.11.0 version."
+)
 def config_list_from_json(
     env_or_file: str,
     file_location: str | None = "",
@@ -669,34 +614,18 @@ def config_list_from_json(
     Raises:
         FileNotFoundError: if env_or_file is neither found as an environment variable nor a file
     """
-    if inspect.stack()[1].function != "from_json":
-        warnings.warn(
-            "config_list_from_json is deprecated and will be removed in a future release. "
-            'Please use the "autogen.LLMConfig.from_json(path="OAI_CONFIG_LIST")" method instead.',
-            DeprecationWarning,
-        )
-
-    env_str = os.environ.get(env_or_file)
-
-    if env_str:
-        # The environment variable exists. We should use information from it.
-        if os.path.exists(env_str):
-            # It is a file location, and we need to load the json from the file.
-            with open(env_str) as file:
-                json_str = file.read()
-        else:
-            # Else, it should be a JSON string by itself.
-            json_str = env_str
-        config_list = json.loads(json_str)
-    else:
-        # The environment variable does not exist.
-        # So, `env_or_file` is a filename. We should use the file location.
-        config_list_path = os.path.join(file_location, env_or_file) if file_location is not None else env_or_file
-
-        with open(config_list_path) as json_file:
-            config_list = json.load(json_file)
+    warnings.warn(
+        "`autogen.config_list_from_json(...)` is deprecated. "
+        'Please use the "autogen.LLMConfig.from_json(path="OAI_CONFIG_LIST")" method instead. '
+        "Scheduled for removal in 0.11.0 version.",
+        DeprecationWarning,
+    )
 
-    return filter_config(config_list, filter_dict)
+    return latest_config_list_from_json(
+        env_or_file=env_or_file,
+        file_location=file_location,
+        filter_dict=filter_dict,
+    )
 
 
 def get_config(

autogen/tools/dependency_injection.py

@@ -15,6 +15,7 @@ from ..doc_utils import export_module
 from ..fast_depends import Depends as FastDepends
 from ..fast_depends import inject
 from ..fast_depends.dependencies import model
+from ..fast_depends.utils import is_coroutine_callable
 
 if TYPE_CHECKING:
     from ..agentchat.conversable_agent import ConversableAgent
@@ -140,10 +141,7 @@ def remove_params(func: Callable[..., Any], sig: inspect.Signature, params: Iter
 
 
 def _remove_injected_params_from_signature(func: Callable[..., Any]) -> Callable[..., Any]:
-    # This is a workaround for Python 3.9+ where staticmethod.__func__ is accessible
-    if sys.version_info >= (3, 9) and isinstance(func, staticmethod) and hasattr(func, "__func__"):
-        func = _fix_staticmethod(func)
-
+    func = _fix_staticmethod(func)
     sig = inspect.signature(func)
     params_to_remove = [p.name for p in sig.parameters.values() if _is_context_param(p) or _is_depends_param(p)]
     remove_params(func, sig, params_to_remove)
@@ -205,7 +203,7 @@ def _fix_staticmethod(f: Callable[..., Any]) -> Callable[..., Any]:
 
 
 def _set_return_annotation_to_any(f: Callable[..., Any]) -> Callable[..., Any]:
-    if inspect.iscoroutinefunction(f):
+    if is_coroutine_callable(f):
 
         @functools.wraps(f)
         async def _a_wrapped_func(*args: Any, **kwargs: Any) -> Any:
@@ -242,9 +240,7 @@ def inject_params(f: Callable[..., Any]) -> Callable[..., Any]:
         The modified function with injected dependencies and updated signature.
     """
     # This is a workaround for Python 3.9+ where staticmethod.__func__ is accessible
-    if sys.version_info >= (3, 9) and isinstance(f, staticmethod) and hasattr(f, "__func__"):
-        f = _fix_staticmethod(f)
-
+    f = _fix_staticmethod(f)
     f = _string_metadata_to_description_field(f)
     f = _set_return_annotation_to_any(f)
     f = inject(f)

autogen/tools/experimental/reliable/reliable.py

@@ -26,6 +26,7 @@ from ....agentchat.group import AgentTarget, ReplyResult, TerminateTarget
 from ....agentchat.group.context_variables import ContextVariables
 from ....agentchat.group.patterns import DefaultPattern
 from ....doc_utils import export_module
+from ....fast_depends.utils import is_coroutine_callable
 from ....llm_config import LLMConfig
 from ....tools.dependency_injection import Field as AG2Field
 from ....tools.tool import Tool
@@ -375,7 +376,7 @@ def reliable_function_wrapper(
     Adds 'hypothesis' and 'context_variables' keyword-only arguments.
     Returns a ReplyResult targeting the validator.
     """
-    is_original_func_async = inspect.iscoroutinefunction(tool_function)
+    is_original_func_async = is_coroutine_callable(tool_function)
     tool_sig = inspect.signature(tool_function)
     wrapper_func: Callable[..., Any]  # Declare type for wrapper_func
 
@@ -653,7 +654,7 @@ class ReliableTool(Tool):
                 Example: `ground_truth=["The API rate limit is 10 requests per minute.", "User preference: only show results from the last 7 days."]`
         """
         self._original_func, original_name, original_description = self._extract_func_details(func_or_tool)
-        self._is_original_func_async = inspect.iscoroutinefunction(self._original_func)
+        self._is_original_func_async = is_coroutine_callable(self._original_func)
 
         self._runner_llm_config = ConversableAgent._validate_llm_config(runner_llm_config)
         if self._runner_llm_config is False:

autogen/tools/experimental/web_search_preview/web_search_preview.py

@@ -49,7 +49,7 @@ class WebSearchPreviewTool(Tool):
                 The default is `None`, which means the text will be returned as a string.
         """
         self.web_search_tool_param = WebSearchToolParam(
-            type="web_search_preview",
+            type="web_search",
             search_context_size=search_context_size,
             user_location=UserLocation(**user_location) if user_location else None,  # type: ignore[typeddict-item]
         )

autogen/tools/function_utils.py

@@ -17,6 +17,7 @@ from pydantic import __version__ as pydantic_version
 from pydantic.json_schema import JsonSchemaValue
 
 from ..doc_utils import export_module
+from ..fast_depends.utils import is_coroutine_callable
 from .dependency_injection import Field as AG2Field
 
 if parse(pydantic_version) < parse("2.10.2"):
@@ -381,7 +382,7 @@ def load_basemodels_if_needed(func: Callable[..., Any]) -> Callable[..., Any]:
         # call the original function
         return await func(*args, **kwargs)
 
-    if inspect.iscoroutinefunction(func):
+    if is_coroutine_callable(func):
         return _a_load_parameters_if_needed
     else:
         return _load_parameters_if_needed

autogen/version.py

@@ -4,4 +4,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.9.9"
+__version__ = "0.9.10"