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

autogen/fast_depends/library/model.py

@@ -6,13 +6,13 @@
 # SPDX-License-Identifier: MIT
 
 from abc import ABC
-from typing import Any, Dict, Optional, TypeVar
+from typing import Any, TypeVar
 
 Cls = TypeVar("Cls", bound="CustomField")
 
 
 class CustomField(ABC):
-    param_name: Optional[str]
+    param_name: str | None
     cast: bool
     required: bool
 
@@ -38,9 +38,9 @@ class CustomField(ABC):
         self.param_name = name
         return self
 
-    def use(self, /, **kwargs: Any) -> Dict[str, Any]:
+    def use(self, /, **kwargs: Any) -> dict[str, Any]:
         assert self.param_name, "You should specify `param_name` before using"
         return kwargs
 
-    def use_field(self, kwargs: Dict[str, Any]) -> None:
+    def use_field(self, kwargs: dict[str, Any]) -> None:
         raise NotImplementedError("You should implement `use_field` method.")

autogen/fast_depends/schema.py

@@ -5,7 +5,7 @@
 # Portions derived from  https://github.com/https://github.com/Lancetnik/FastDepends are under the MIT License.
 # SPDX-License-Identifier: MIT
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from ._compat import PYDANTIC_V2, create_model, model_schema
 from .core import CallModel
@@ -15,13 +15,13 @@ def get_schema(
     call: CallModel[Any, Any],
     embed: bool = False,
     resolve_refs: bool = False,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     assert call.model, "Call should has a model"
     params_model = create_model(  # type: ignore[call-overload]
         call.model.__name__, **call.flat_params
     )
 
-    body: Dict[str, Any] = model_schema(params_model)
+    body: dict[str, Any] = model_schema(params_model)
 
     if not call.flat_params:
         body = {"title": body["title"], "type": "null"}
@@ -37,8 +37,8 @@ def get_schema(
     return body
 
 
-def _move_pydantic_refs(original: Any, key: str, refs: Optional[Dict[str, Any]] = None) -> Any:
-    if not isinstance(original, Dict):
+def _move_pydantic_refs(original: Any, key: str, refs: dict[str, Any] | None = None) -> Any:
+    if not isinstance(original, dict):
         return original
 
     data = original.copy()
@@ -47,7 +47,7 @@ def _move_pydantic_refs(original: Any, key: str, refs: Optional[Dict[str, Any]]
         raw_refs = data.get(key, {})
         refs = _move_pydantic_refs(raw_refs, key, raw_refs)
 
-    name: Optional[str] = None
+    name: str | None = None
     for k in data:
         if k == "$ref":
             name = data[k].replace(f"#/{key}/", "")
@@ -55,7 +55,7 @@ def _move_pydantic_refs(original: Any, key: str, refs: Optional[Dict[str, Any]]
         elif isinstance(data[k], dict):
             data[k] = _move_pydantic_refs(data[k], key, refs)
 
-        elif isinstance(data[k], List):
+        elif isinstance(data[k], list):
             for i in range(len(data[k])):
                 data[k][i] = _move_pydantic_refs(data[k][i], key, refs)
 

autogen/fast_depends/use.py

@@ -5,18 +5,13 @@
 # Portions derived from  https://github.com/https://github.com/Lancetnik/FastDepends are under the MIT License.
 # SPDX-License-Identifier: MIT
 
+from collections.abc import AsyncIterator, Callable, Iterator, Sequence
 from contextlib import AsyncExitStack, ExitStack
 from functools import partial, wraps
 from typing import (
     Any,
-    AsyncIterator,
-    Callable,
-    Iterator,
-    Optional,
     Protocol,
-    Sequence,
     TypeVar,
-    Union,
     cast,
     overload,
 )
@@ -48,7 +43,7 @@ class _InjectWrapper(Protocol[P, T]):
     def __call__(
         self,
         func: Callable[P, T],
-        model: Optional[CallModel[P, T]] = None,
+        model: CallModel[P, T] | None = None,
     ) -> Callable[P, T]: ...
 
 
@@ -58,8 +53,8 @@ def inject(  # pragma: no cover
     *,
     cast: bool = True,
     extra_dependencies: Sequence[model.Depends] = (),
-    pydantic_config: Optional[ConfigDict] = None,
-    dependency_overrides_provider: Optional[Any] = dependency_provider,
+    pydantic_config: ConfigDict | None = None,
+    dependency_overrides_provider: Any | None = dependency_provider,
     wrap_model: Callable[[CallModel[P, T]], CallModel[P, T]] = lambda x: x,
 ) -> _InjectWrapper[P, T]: ...
 
@@ -70,24 +65,21 @@ def inject(  # pragma: no cover
     *,
     cast: bool = True,
     extra_dependencies: Sequence[model.Depends] = (),
-    pydantic_config: Optional[ConfigDict] = None,
-    dependency_overrides_provider: Optional[Any] = dependency_provider,
+    pydantic_config: ConfigDict | None = None,
+    dependency_overrides_provider: Any | None = dependency_provider,
     wrap_model: Callable[[CallModel[P, T]], CallModel[P, T]] = lambda x: x,
 ) -> Callable[P, T]: ...
 
 
 def inject(
-    func: Optional[Callable[P, T]] = None,
+    func: Callable[P, T] | None = None,
     *,
     cast: bool = True,
     extra_dependencies: Sequence[model.Depends] = (),
-    pydantic_config: Optional[ConfigDict] = None,
-    dependency_overrides_provider: Optional[Any] = dependency_provider,
+    pydantic_config: ConfigDict | None = None,
+    dependency_overrides_provider: Any | None = dependency_provider,
     wrap_model: Callable[[CallModel[P, T]], CallModel[P, T]] = lambda x: x,
-) -> Union[
-    Callable[P, T],
-    _InjectWrapper[P, T],
-]:
+) -> Callable[P, T] | _InjectWrapper[P, T]:
     decorator = _wrap_inject(
         dependency_overrides_provider=dependency_overrides_provider,
         wrap_model=wrap_model,
@@ -104,14 +96,14 @@ def inject(
 
 
 def _wrap_inject(
-    dependency_overrides_provider: Optional[Any],
+    dependency_overrides_provider: Any | None,
     wrap_model: Callable[
         [CallModel[P, T]],
         CallModel[P, T],
     ],
     extra_dependencies: Sequence[model.Depends],
     cast: bool,
-    pydantic_config: Optional[ConfigDict],
+    pydantic_config: ConfigDict | None,
 ) -> _InjectWrapper[P, T]:
     if (
         dependency_overrides_provider
@@ -123,7 +115,7 @@ def _wrap_inject(
 
     def func_wrapper(
         func: Callable[P, T],
-        model: Optional[CallModel[P, T]] = None,
+        model: CallModel[P, T] | None = None,
     ) -> Callable[P, T]:
         if model is None:
             real_model = wrap_model(
@@ -187,12 +179,12 @@ def _wrap_inject(
 
 
 class solve_async_gen:  # noqa: N801
-    _iter: Optional[AsyncIterator[Any]] = None
+    _iter: AsyncIterator[Any] | None = None
 
     def __init__(
         self,
         model: "CallModel[..., Any]",
-        overrides: Optional[Any],
+        overrides: Any | None,
         *args: Any,
         **kwargs: Any,
     ):
@@ -234,12 +226,12 @@ class solve_async_gen:  # noqa: N801
 
 
 class solve_gen:  # noqa: N801
-    _iter: Optional[Iterator[Any]] = None
+    _iter: Iterator[Any] | None = None
 
     def __init__(
         self,
         model: "CallModel[..., Any]",
-        overrides: Optional[Any],
+        overrides: Any | None,
         *args: Any,
         **kwargs: Any,
     ):

autogen/fast_depends/utils.py

@@ -8,30 +8,13 @@
 import asyncio
 import functools
 import inspect
-from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncGenerator,
-    AsyncIterable,
-    Awaitable,
-    Callable,
-    ContextManager,
-    Dict,
-    ForwardRef,
-    List,
-    Tuple,
-    TypeVar,
-    Union,
-    cast,
-)
+from collections.abc import AsyncGenerator, AsyncIterable, Awaitable, Callable
+from contextlib import AbstractContextManager, AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
+from typing import TYPE_CHECKING, Annotated, Any, ForwardRef, TypeVar, cast, get_args, get_origin
 
 import anyio
 from typing_extensions import (
-    Annotated,
     ParamSpec,
-    get_args,
-    get_origin,
 )
 
 from ._compat import evaluate_forwardref
@@ -44,10 +27,7 @@ T = TypeVar("T")
 
 
 async def run_async(
-    func: Union[
-        Callable[P, T],
-        Callable[P, Awaitable[T]],
-    ],
+    func: Callable[P, T] | Callable[P, Awaitable[T]],
     *args: P.args,
     **kwargs: P.kwargs,
 ) -> T:
@@ -78,7 +58,7 @@ def solve_generator_sync(*sub_args: Any, call: Callable[..., Any], stack: ExitSt
     return stack.enter_context(cm)
 
 
-def get_typed_signature(call: Callable[..., Any]) -> Tuple[inspect.Signature, Any]:
+def get_typed_signature(call: Callable[..., Any]) -> tuple[inspect.Signature, Any]:
     signature = inspect.signature(call)
 
     locals = collect_outer_stack_locals()
@@ -108,10 +88,10 @@ def get_typed_signature(call: Callable[..., Any]) -> Tuple[inspect.Signature, An
     )
 
 
-def collect_outer_stack_locals() -> Dict[str, Any]:
+def collect_outer_stack_locals() -> dict[str, Any]:
     frame = inspect.currentframe()
 
-    frames: List[FrameType] = []
+    frames: list[FrameType] = []
     while frame is not None:
         if "fast_depends" not in frame.f_code.co_filename:
             frames.append(frame)
@@ -126,8 +106,8 @@ def collect_outer_stack_locals() -> Dict[str, Any]:
 
 def get_typed_annotation(
     annotation: Any,
-    globalns: Dict[str, Any],
-    locals: Dict[str, Any],
+    globalns: dict[str, Any],
+    locals: dict[str, Any],
 ) -> Any:
     if isinstance(annotation, str):
         annotation = ForwardRef(annotation)
@@ -144,7 +124,7 @@ def get_typed_annotation(
 
 @asynccontextmanager
 async def contextmanager_in_threadpool(
-    cm: ContextManager[T],
+    cm: AbstractContextManager[T],
 ) -> AsyncGenerator[T, None]:
     exit_limiter = anyio.CapacityLimiter(1)
     try:

autogen/formatting_utils.py

@@ -7,7 +7,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterable
-from typing import Literal, Optional
+from typing import Literal
 
 from .import_utils import optional_import_block
 
@@ -70,12 +70,12 @@ if not result.is_successful:
 
     def colored(
         text: object,
-        color: Optional[Color] = None,
-        on_color: Optional[Highlight] = None,
-        attrs: Optional[Iterable[Attribute]] = None,
+        color: Color | None = None,
+        on_color: Highlight | None = None,
+        attrs: Iterable[Attribute] | None = None,
         *,
-        no_color: Optional[bool] = None,
-        force_color: Optional[bool] = None,
+        no_color: bool | None = None,
+        force_color: bool | None = None,
     ) -> str:
         return str(text)
 

autogen/graph_utils.py

@@ -6,7 +6,6 @@
 # SPDX-License-Identifier: MIT
 
 import logging
-from typing import Optional
 
 from .agentchat import Agent
 from .import_utils import optional_import_block, require_optional_import
@@ -25,7 +24,6 @@ def has_self_loops(allowed_speaker_transitions: dict[str, list[Agent]]) -> bool:
     Returns:
         True if there are self loops in the allowed_speaker_transitions_Dict.
     """
-
     return any([key in value for key, value in allowed_speaker_transitions.items()])
 
 
@@ -144,7 +142,7 @@ def invert_disallowed_to_allowed(
 
 @require_optional_import(["matplotlib", "networkx"], "graph")
 def visualize_speaker_transitions_dict(
-    speaker_transitions_dict: dict[str, list[Agent]], agents: list[Agent], export_path: Optional[str] = None
+    speaker_transitions_dict: dict[str, list[Agent]], agents: list[Agent], export_path: str | None = None
 ) -> None:
     """Visualize the speaker_transitions_dict using networkx.
 
@@ -158,7 +156,6 @@ def visualize_speaker_transitions_dict(
 
 
     """
-
     g = nx.DiGraph()
 
     # Add nodes

autogen/import_utils.py

@@ -6,12 +6,15 @@ import inspect
 import re
 import sys
 from abc import ABC, abstractmethod
+from collections.abc import Callable, Generator, Iterable
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass
 from functools import wraps
 from logging import getLogger
 from pathlib import Path
-from typing import Any, Callable, Generator, Generic, Iterable, Optional, TypeVar, Union
+from typing import Any, Generic, Optional, TypeVar
+
+from packaging import version
 
 __all__ = [
     "optional_import_block",
@@ -27,12 +30,12 @@ logger = getLogger(__name__)
 @dataclass
 class ModuleInfo:
     name: str
-    min_version: Optional[str] = None
-    max_version: Optional[str] = None
+    min_version: str | None = None
+    max_version: str | None = None
     min_inclusive: bool = False
     max_inclusive: bool = False
 
-    def is_in_sys_modules(self) -> Optional[str]:
+    def is_in_sys_modules(self) -> str | None:
         """Check if the module is installed and satisfies the version constraints
 
         Returns:
@@ -52,25 +55,34 @@ class ModuleInfo:
                     # Aka similarly named module in the autogen or test directory
                     return f"'{self.name}' is not installed."
 
-        installed_version = (
+        # Ensure that the retrieved version is a string. Some packages might unexpectedly
+        # have a __version__ attribute that is not a string (e.g., a module).
+        raw_version_attr = (
             sys.modules[self.name].__version__ if hasattr(sys.modules[self.name], "__version__") else None
         )
+        installed_version = raw_version_attr if isinstance(raw_version_attr, str) else None
         if installed_version is None and (self.min_version or self.max_version):
             return f"'{self.name}' is installed, but the version is not available."
 
-        if self.min_version:
-            msg = f"'{self.name}' is installed, but the installed version {installed_version} is too low (required '{self}')."
-            if not self.min_inclusive and installed_version == self.min_version:
-                return msg
-            if self.min_inclusive and installed_version < self.min_version:  # type: ignore[operator]
-                return msg
-
-        if self.max_version:
-            msg = f"'{self.name}' is installed, but the installed version {installed_version} is too high (required '{self}')."
-            if not self.max_inclusive and installed_version == self.max_version:
-                return msg
-            if self.max_inclusive and installed_version > self.max_version:  # type: ignore[operator]
-                return msg
+        if installed_version:
+            # Convert to version object for comparison
+            installed_ver = version.parse(installed_version)
+
+            if self.min_version:
+                min_ver = version.parse(self.min_version)
+                msg = f"'{self.name}' is installed, but the installed version {installed_version} is too low (required '{self}')."
+                if not self.min_inclusive and installed_ver == min_ver:
+                    return msg
+                if self.min_inclusive and installed_ver < min_ver:
+                    return msg
+
+            if self.max_version:
+                max_ver = version.parse(self.max_version)
+                msg = f"'{self.name}' is installed, but the installed version {installed_version} is too high (required '{self}')."
+                if not self.max_inclusive and installed_ver == max_ver:
+                    return msg
+                if self.max_inclusive and installed_ver > max_ver:
+                    return msg
 
         return None
 
@@ -95,7 +107,6 @@ class ModuleInfo:
         Raises:
             ValueError: If the module information is invalid
         """
-
         pattern = re.compile(r"^(?P<name>[a-zA-Z0-9-_]+)(?P<constraint>.*)$")
         match = pattern.match(module_info.strip())
 
@@ -140,7 +151,7 @@ class ModuleInfo:
 
 class Result:
     def __init__(self) -> None:
-        self._failed: Optional[bool] = None
+        self._failed: bool | None = None
 
     @property
     def is_successful(self) -> bool:
@@ -173,7 +184,7 @@ def optional_import_block() -> Generator[Result, None, None]:
         result._failed = True
 
 
-def get_missing_imports(modules: Union[str, Iterable[str]]) -> dict[str, str]:
+def get_missing_imports(modules: str | Iterable[str]) -> dict[str, str]:
     """Get missing modules from a list of module names
 
     Args:
@@ -191,7 +202,7 @@ def get_missing_imports(modules: Union[str, Iterable[str]]) -> dict[str, str]:
 
 
 T = TypeVar("T")
-G = TypeVar("G", bound=Union[Callable[..., Any], type])
+G = TypeVar("G", bound=Callable[..., Any] | type)
 F = TypeVar("F", bound=Callable[..., Any])
 
 
@@ -401,7 +412,7 @@ def patch_object(
     missing_modules: dict[str, str],
     dep_target: str,
     fail_if_not_patchable: bool = True,
-    except_for: Optional[Union[str, Iterable[str]]] = None,
+    except_for: str | Iterable[str] | None = None,
 ) -> T:
     patcher = PatchObject.create(o, missing_modules=missing_modules, dep_target=dep_target)
     if fail_if_not_patchable and patcher is None:
@@ -414,10 +425,10 @@ def patch_object(
 
 
 def require_optional_import(
-    modules: Union[str, Iterable[str]],
+    modules: str | Iterable[str],
     dep_target: str,
     *,
-    except_for: Optional[Union[str, Iterable[str]]] = None,
+    except_for: str | Iterable[str] | None = None,
 ) -> Callable[[T], T]:
     """Decorator to handle optional module dependencies
 
@@ -453,7 +464,7 @@ def _mark_object(o: T, dep_target: str) -> T:
     return pytest_mark_o  # type: ignore[no-any-return]
 
 
-def run_for_optional_imports(modules: Union[str, Iterable[str]], dep_target: str) -> Callable[[G], G]:
+def run_for_optional_imports(modules: str | Iterable[str], dep_target: str) -> Callable[[G], G]:
     """Decorator to run a test if and only if optional modules are installed
 
     Args:
@@ -497,7 +508,7 @@ def run_for_optional_imports(modules: Union[str, Iterable[str]], dep_target: str
     return decorator
 
 
-def skip_on_missing_imports(modules: Union[str, Iterable[str]], dep_target: str) -> Callable[[T], T]:
+def skip_on_missing_imports(modules: str | Iterable[str], dep_target: str) -> Callable[[T], T]:
     """Decorator to skip a test if an optional module is missing
 
     Args:

autogen/interop/crewai/crewai.py

@@ -4,7 +4,7 @@
 
 import re
 import sys
-from typing import Any, Optional
+from typing import Any
 
 from ...doc_utils import export_module
 from ...import_utils import optional_import_block, require_optional_import
@@ -75,7 +75,7 @@ class CrewAIInteroperability:
         )
 
     @classmethod
-    def get_unsupported_reason(cls) -> Optional[str]:
+    def get_unsupported_reason(cls) -> str | None:
         if sys.version_info < (3, 10) or sys.version_info >= (3, 13):
             return "This submodule is only supported for Python versions 3.10, 3.11, and 3.12"
 

autogen/interop/interoperable.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Optional, Protocol, runtime_checkable
+from typing import Any, Protocol, runtime_checkable
 
 from ..doc_utils import export_module
 from ..tools import Tool
@@ -35,7 +35,7 @@ class Interoperable(Protocol):
         ...
 
     @classmethod
-    def get_unsupported_reason(cls) -> Optional[str]:
+    def get_unsupported_reason(cls) -> str | None:
         """Returns the reason for the tool being unsupported.
 
         This method should be implemented by any class adhering to the `Interoperable` protocol.

autogen/interop/langchain/langchain_chat_model_factory.py

@@ -3,7 +3,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from abc import ABC, abstractmethod
-from typing import Any, Callable, TypeVar, Union
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from ...doc_utils import export_module
 from ...import_utils import optional_import_block, require_optional_import
@@ -33,7 +34,7 @@ class LangChainChatModelFactory(ABC):
     _factories: set["LangChainChatModelFactory"] = set()
 
     @classmethod
-    def create_base_chat_model(cls, llm_config: Union[LLMConfig, dict[str, Any]]) -> "BaseChatModel":  # type: ignore [no-any-unimported]
+    def create_base_chat_model(cls, llm_config: LLMConfig | dict[str, Any]) -> "BaseChatModel":  # type: ignore [no-any-unimported]
         first_llm_config = get_first_llm_config(llm_config)
         for factory in LangChainChatModelFactory._factories:
             if factory.accepts(first_llm_config):

autogen/interop/langchain/langchain_tool.py

@@ -2,8 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import sys
-from typing import Any, Optional
+from typing import Any
 
 from ...doc_utils import export_module
 from ...import_utils import optional_import_block, require_optional_import
@@ -67,10 +66,7 @@ class LangChainInteroperability:
         )
 
     @classmethod
-    def get_unsupported_reason(cls) -> Optional[str]:
-        if sys.version_info < (3, 9):
-            return "This submodule is only supported for Python versions 3.9 and above"
-
+    def get_unsupported_reason(cls) -> str | None:
         with optional_import_block() as result:
             import langchain_core.tools  # noqa: F401
 

autogen/interop/litellm/litellm_config_factory.py

@@ -4,7 +4,8 @@
 
 import os
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from ...doc_utils import export_module
 from ...llm_config import LLMConfig
@@ -15,7 +16,7 @@ __all__ = ["LiteLLmConfigFactory"]
 T = TypeVar("T", bound="LiteLLmConfigFactory")
 
 
-def get_crawl4ai_version() -> Optional[str]:
+def get_crawl4ai_version() -> str | None:
     """Get the installed crawl4ai version."""
     try:
         import crawl4ai
@@ -46,9 +47,8 @@ class LiteLLmConfigFactory(ABC):
     _factories: set["LiteLLmConfigFactory"] = set()
 
     @classmethod
-    def create_lite_llm_config(cls, llm_config: Union[LLMConfig, dict[str, Any]]) -> dict[str, Any]:
-        """
-        Create a lite LLM config compatible with the installed crawl4ai version.
+    def create_lite_llm_config(cls, llm_config: LLMConfig | dict[str, Any]) -> dict[str, Any]:
+        """Create a lite LLM config compatible with the installed crawl4ai version.
 
         For crawl4ai >=0.5: Returns config with llmConfig parameter
         For crawl4ai <0.5: Returns config with provider parameter (legacy)
@@ -68,8 +68,7 @@ class LiteLLmConfigFactory(ABC):
 
     @classmethod
     def _adapt_for_crawl4ai_v05(cls, base_config: dict[str, Any]) -> dict[str, Any]:
-        """
-        Adapt the config for crawl4ai >=0.5 by moving deprecated parameters
+        """Adapt the config for crawl4ai >=0.5 by moving deprecated parameters
         into an llmConfig object.
         """
         adapted_config = base_config.copy()

autogen/interop/pydantic_ai/pydantic_ai.py

@@ -3,11 +3,11 @@
 # SPDX-License-Identifier: Apache-2.0
 
 
-import sys
 import warnings
+from collections.abc import Callable
 from functools import wraps
 from inspect import signature
-from typing import Any, Callable, Optional
+from typing import Any
 
 from ...doc_utils import export_module
 from ...import_utils import optional_import_block, require_optional_import
@@ -55,7 +55,7 @@ class PydanticAIInteroperability:
         Raises:
             ValueError: If the tool fails after the maximum number of retries.
         """
-        ctx_typed: Optional[RunContext[Any]] = ctx  # type: ignore[no-any-unimported]
+        ctx_typed: RunContext[Any] | None = ctx  # type: ignore[no-any-unimported]
         tool_typed: PydanticAITool[Any] = tool  # type: ignore[no-any-unimported]
 
         max_retries = tool_typed.max_retries if tool_typed.max_retries is not None else 1
@@ -155,10 +155,7 @@ class PydanticAIInteroperability:
         )
 
     @classmethod
-    def get_unsupported_reason(cls) -> Optional[str]:
-        if sys.version_info < (3, 9):
-            return "This submodule is only supported for Python versions 3.9 and above"
-
+    def get_unsupported_reason(cls) -> str | None:
         with optional_import_block() as result:
             import pydantic_ai.tools  # noqa: F401
 

autogen/interop/registry.py

@@ -2,7 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Callable, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 from ..doc_utils import export_module
 from .interoperable import Interoperable