ag2 0.9.6__py3-none-any.whl → 0.9.8.post1__py3-none-any.whl

autogen/events/base_event.py

@@ -4,7 +4,8 @@
 
 
 from abc import ABC
-from typing import Annotated, Any, Callable, Literal, Optional, Union
+from collections.abc import Callable
+from typing import Annotated, Any, Literal, Union
 from uuid import UUID, uuid4
 
 from pydantic import BaseModel, Field, create_model
@@ -18,11 +19,11 @@ __all__ = ["BaseEvent", "get_annotated_type_for_event_classes", "get_event_class
 class BaseEvent(BaseModel, ABC):
     uuid: UUID
 
-    def __init__(self, uuid: Optional[UUID] = None, **kwargs: Any) -> None:
+    def __init__(self, uuid: UUID | None = None, **kwargs: Any) -> None:
         uuid = uuid or uuid4()
         super().__init__(uuid=uuid, **kwargs)
 
-    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+    def print(self, f: Callable[..., Any] | None = None) -> None:
         """Print event
 
         Args:
@@ -70,7 +71,7 @@ def wrap_event(event_cls: type[BaseEvent]) -> type[BaseModel]:
                 else:
                     super().__init__(content=event_cls(*args, **data), **data)
 
-        def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+        def print(self, f: Callable[..., Any] | None = None) -> None:
             self.content.print(f)  # type: ignore[attr-defined]
 
     wrapper_cls = create_model(event_cls.__name__, __base__=WrapperBase)
@@ -91,7 +92,7 @@ def wrap_event(event_cls: type[BaseEvent]) -> type[BaseModel]:
 @export_module("autogen.events")
 def get_annotated_type_for_event_classes() -> type[Any]:
     # this is a dynamic type so we need to disable the type checker
-    union_type = Union[tuple(_event_classes.values())]  # type: ignore[valid-type]
+    union_type = Union[tuple(_event_classes.values())]  # type: ignore[valid-type]  # noqa: UP007
     return Annotated[union_type, Field(discriminator="type")]  # type: ignore[return-value]
 
 

autogen/events/client_events.py

@@ -2,7 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Callable, Literal, Optional, Union
+from collections.abc import Callable
+from typing import Any, Literal
 from uuid import UUID
 
 from pydantic import BaseModel
@@ -30,18 +31,18 @@ class ModelUsageSummary(BaseModel):
 class ActualUsageSummary(BaseModel):
     """Actual usage summary."""
 
-    usages: Optional[list[ModelUsageSummary]] = None
+    usages: list[ModelUsageSummary] | None = None
     """List of model usage summaries."""
-    total_cost: Optional[float] = None
+    total_cost: float | None = None
     """Total cost."""
 
 
 class TotalUsageSummary(BaseModel):
     """Total usage summary."""
 
-    usages: Optional[list[ModelUsageSummary]] = None
+    usages: list[ModelUsageSummary] | None = None
     """List of model usage summaries."""
-    total_cost: Optional[float] = None
+    total_cost: float | None = None
     """Total cost."""
 
 
@@ -49,7 +50,7 @@ Mode = Literal["both", "total", "actual"]
 
 
 def _change_usage_summary_format(
-    actual_usage_summary: Optional[dict[str, Any]] = None, total_usage_summary: Optional[dict[str, Any]] = None
+    actual_usage_summary: dict[str, Any] | None = None, total_usage_summary: dict[str, Any] | None = None
 ) -> dict[str, dict[str, Any]]:
     summary: dict[str, Any] = {}
 
@@ -85,9 +86,9 @@ class UsageSummaryEvent(BaseEvent):
     def __init__(
         self,
         *,
-        uuid: Optional[UUID] = None,
-        actual_usage_summary: Optional[dict[str, Any]] = None,
-        total_usage_summary: Optional[dict[str, Any]] = None,
+        uuid: UUID | None = None,
+        actual_usage_summary: dict[str, Any] | None = None,
+        total_usage_summary: dict[str, Any] | None = None,
         mode: Mode = "both",
     ):
         # print(f"{actual_usage_summary=}")
@@ -99,9 +100,9 @@ class UsageSummaryEvent(BaseEvent):
 
     def _print_usage(
         self,
-        usage_summary: Union[ActualUsageSummary, TotalUsageSummary],
+        usage_summary: ActualUsageSummary | TotalUsageSummary,
         usage_type: str = "total",
-        f: Optional[Callable[..., Any]] = None,
+        f: Callable[..., Any] | None = None,
     ) -> None:
         f = f or print
         word_from_type = "including" if usage_type == "total" else "excluding"
@@ -118,7 +119,7 @@ class UsageSummaryEvent(BaseEvent):
                 flush=True,
             )
 
-    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+    def print(self, f: Callable[..., Any] | None = None) -> None:
         f = f or print
 
         if self.total.usages is None:
@@ -152,10 +153,10 @@ class StreamEvent(BaseEvent):
     content: str
     """Content of the event."""
 
-    def __init__(self, *, uuid: Optional[UUID] = None, content: str) -> None:
+    def __init__(self, *, uuid: UUID | None = None, content: str) -> None:
         super().__init__(uuid=uuid, content=content)
 
-    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+    def print(self, f: Callable[..., Any] | None = None) -> None:
         f = f or print
 
         # Set the terminal text color to green

autogen/events/helpers.py

@@ -2,8 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 import logging
+from collections.abc import Callable
 from functools import wraps
-from typing import Callable
 
 from pydantic import BaseModel
 

autogen/events/print_event.py

@@ -4,7 +4,8 @@
 
 
 import json
-from typing import Any, Callable, Optional
+from collections.abc import Callable
+from typing import Any
 from uuid import UUID
 
 from .base_event import BaseEvent, wrap_event
@@ -21,9 +22,7 @@ class PrintEvent(BaseEvent):
     end: str
     """End of the print"""
 
-    def __init__(
-        self, *objects: Any, sep: str = " ", end: str = "\n", flush: bool = False, uuid: Optional[UUID] = None
-    ):
+    def __init__(self, *objects: Any, sep: str = " ", end: str = "\n", flush: bool = False, uuid: UUID | None = None):
         objects_as_string = [self._to_json(x) for x in objects]
 
         super().__init__(uuid=uuid, objects=objects_as_string, sep=sep, end=end)
@@ -40,7 +39,7 @@ class PrintEvent(BaseEvent):
             return str(obj)
             # return repr(obj)
 
-    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+    def print(self, f: Callable[..., Any] | None = None) -> None:
         f = f or print
 
         f(*self.objects, sep=self.sep, end=self.end, flush=True)

autogen/fast_depends/_compat.py

@@ -6,8 +6,7 @@
 # SPDX-License-Identifier: MIT
 
 import sys
-from importlib.metadata import version as get_version
-from typing import Any, Dict, Optional, Tuple, Type
+from typing import Any
 
 from pydantic import BaseModel, create_model
 from pydantic.version import VERSION as PYDANTIC_VERSION
@@ -35,13 +34,13 @@ if PYDANTIC_V2:
         eval_type_lenient as evaluate_forwardref,
     )
 
-    def model_schema(model: Type[BaseModel]) -> Dict[str, Any]:
+    def model_schema(model: type[BaseModel]) -> dict[str, Any]:
         return model.model_json_schema()
 
-    def get_config_base(config_data: Optional[ConfigDict] = None) -> ConfigDict:
+    def get_config_base(config_data: ConfigDict | None = None) -> ConfigDict:
         return config_data or ConfigDict(**default_pydantic_config)  # type: ignore[typeddict-item]
 
-    def get_aliases(model: Type[BaseModel]) -> Tuple[str, ...]:
+    def get_aliases(model: type[BaseModel]) -> tuple[str, ...]:
         return tuple(f.alias or name for name, f in model.model_fields.items())
 
     class CreateBaseModel(BaseModel):
@@ -53,13 +52,13 @@ else:
     from pydantic.typing import evaluate_forwardref as evaluate_forwardref  # type: ignore[no-redef]
     from pydantic.config import get_config, ConfigDict, BaseConfig
 
-    def get_config_base(config_data: Optional[ConfigDict] = None) -> Type[BaseConfig]:  # type: ignore[misc,no-any-unimported]
+    def get_config_base(config_data: ConfigDict | None = None) -> type[BaseConfig]:  # type: ignore[misc,no-any-unimported]
         return get_config(config_data or ConfigDict(**default_pydantic_config))  # type: ignore[typeddict-item,no-any-unimported,no-any-return]
 
-    def model_schema(model: Type[BaseModel]) -> Dict[str, Any]:
+    def model_schema(model: type[BaseModel]) -> dict[str, Any]:
         return model.schema()
 
-    def get_aliases(model: Type[BaseModel]) -> Tuple[str, ...]:
+    def get_aliases(model: type[BaseModel]) -> tuple[str, ...]:
         return tuple(f.alias or name for name, f in model.__fields__.items())  # type: ignore[attr-defined]
 
     class CreateBaseModel(BaseModel):  # type: ignore[no-redef]
@@ -69,12 +68,8 @@ else:
             arbitrary_types_allowed = True
 
 
-ANYIO_V3 = get_version("anyio").startswith("3.")
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup as ExceptionGroup
 
-if ANYIO_V3:
-    from anyio import ExceptionGroup as ExceptionGroup  # type: ignore[attr-defined]
 else:
-    if sys.version_info < (3, 11):
-        from exceptiongroup import ExceptionGroup as ExceptionGroup
-    else:
-        ExceptionGroup = ExceptionGroup
+    ExceptionGroup = ExceptionGroup

autogen/fast_depends/core/build.py

@@ -6,27 +6,11 @@
 # SPDX-License-Identifier: MIT
 
 import inspect
+from collections.abc import Awaitable, Callable, Sequence
 from copy import deepcopy
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from typing import Annotated, Any, TypeVar, get_args, get_origin
 
-from typing_extensions import (
-    Annotated,
-    ParamSpec,
-    get_args,
-    get_origin,
-)
+from typing_extensions import ParamSpec
 
 from .._compat import ConfigDict, create_model, get_config_base
 from ..dependencies import Depends
@@ -47,16 +31,13 @@ T = TypeVar("T")
 
 
 def build_call_model(
-    call: Union[
-        Callable[P, T],
-        Callable[P, Awaitable[T]],
-    ],
+    call: Callable[P, T] | Callable[P, Awaitable[T]],
     *,
     cast: bool = True,
     use_cache: bool = True,
-    is_sync: Optional[bool] = None,
+    is_sync: bool | None = None,
     extra_dependencies: Sequence[Depends] = (),
-    pydantic_config: Optional[ConfigDict] = None,
+    pydantic_config: ConfigDict | None = None,
 ) -> CallModel[P, T]:
     name = getattr(call, "__name__", type(call).__name__)
 
@@ -72,17 +53,17 @@ def build_call_model(
     ):
         return_annotation = return_args[0]
 
-    class_fields: Dict[str, Tuple[Any, Any]] = {}
-    dependencies: Dict[str, CallModel[..., Any]] = {}
-    custom_fields: Dict[str, CustomField] = {}
-    positional_args: List[str] = []
-    keyword_args: List[str] = []
-    var_positional_arg: Optional[str] = None
-    var_keyword_arg: Optional[str] = None
+    class_fields: dict[str, tuple[Any, Any]] = {}
+    dependencies: dict[str, CallModel[..., Any]] = {}
+    custom_fields: dict[str, CustomField] = {}
+    positional_args: list[str] = []
+    keyword_args: list[str] = []
+    var_positional_arg: str | None = None
+    var_keyword_arg: str | None = None
 
     for param_name, param in typed_params.parameters.items():
-        dep: Optional[Depends] = None
-        custom: Optional[CustomField] = None
+        dep: Depends | None = None
+        custom: CustomField | None = None
 
         if param.annotation is inspect.Parameter.empty:
             annotation = Any
@@ -173,7 +154,7 @@ def build_call_model(
                 class_fields[param_name] = (annotation, default)
 
             else:
-                class_fields[param_name] = class_fields.get(param_name, (Optional[annotation], None))
+                class_fields[param_name] = class_fields.get(param_name, (annotation | None, None))
 
             keyword_args.append(param_name)
 
@@ -189,7 +170,7 @@ def build_call_model(
         **class_fields,
     )
 
-    response_model: Optional[Type[ResponseModel[T]]] = None
+    response_model: type[ResponseModel[T]] | None = None
     if cast and return_annotation and return_annotation is not inspect.Parameter.empty:
         response_model = create_model(  # type: ignore[call-overload,assignment]
             "ResponseModel",

autogen/fast_depends/core/model.py

@@ -6,25 +6,15 @@
 # SPDX-License-Identifier: MIT
 
 from collections import namedtuple
+from collections.abc import Awaitable, Callable, Generator, Iterable, Sequence
 from contextlib import AsyncExitStack, ExitStack
 from functools import partial
 from inspect import Parameter, unwrap
 from itertools import chain
 from typing import (
     Any,
-    Awaitable,
-    Callable,
-    Dict,
-    Generator,
     Generic,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
 )
 
 import anyio
@@ -54,26 +44,23 @@ class ResponseModel(BaseModel, Generic[T]):
 
 
 class CallModel(Generic[P, T]):
-    call: Union[
-        Callable[P, T],
-        Callable[P, Awaitable[T]],
-    ]
+    call: Callable[P, T] | Callable[P, Awaitable[T]]
     is_async: bool
     is_generator: bool
-    model: Optional[Type[BaseModel]]
-    response_model: Optional[Type[ResponseModel[T]]]
+    model: type[BaseModel] | None
+    response_model: type[ResponseModel[T]] | None
 
-    params: Dict[str, Tuple[Any, Any]]
-    alias_arguments: Tuple[str, ...]
+    params: dict[str, tuple[Any, Any]]
+    alias_arguments: tuple[str, ...]
 
-    dependencies: Dict[str, "CallModel[..., Any]"]
+    dependencies: dict[str, "CallModel[..., Any]"]
     extra_dependencies: Iterable["CallModel[..., Any]"]
-    sorted_dependencies: Tuple[Tuple["CallModel[..., Any]", int], ...]
-    custom_fields: Dict[str, CustomField]
-    keyword_args: Tuple[str, ...]
-    positional_args: Tuple[str, ...]
-    var_positional_arg: Optional[str]
-    var_keyword_arg: Optional[str]
+    sorted_dependencies: tuple[tuple["CallModel[..., Any]", int], ...]
+    custom_fields: dict[str, CustomField]
+    keyword_args: tuple[str, ...]
+    positional_args: tuple[str, ...]
+    var_positional_arg: str | None
+    var_keyword_arg: str | None
 
     # Dependencies and custom fields
     use_cache: bool
@@ -105,7 +92,7 @@ class CallModel(Generic[P, T]):
         return getattr(call, "__name__", type(call).__name__)
 
     @property
-    def flat_params(self) -> Dict[str, Tuple[Any, Any]]:
+    def flat_params(self) -> dict[str, tuple[Any, Any]]:
         params = self.params
         for d in (*self.dependencies.values(), *self.extra_dependencies):
             params.update(d.flat_params)
@@ -114,18 +101,18 @@ class CallModel(Generic[P, T]):
     @property
     def flat_dependencies(
         self,
-    ) -> Dict[
+    ) -> dict[
         Callable[..., Any],
-        Tuple[
+        tuple[
             "CallModel[..., Any]",
-            Tuple[Callable[..., Any], ...],
+            tuple[Callable[..., Any], ...],
         ],
     ]:
-        flat: Dict[
+        flat: dict[
             Callable[..., Any],
-            Tuple[
+            tuple[
                 CallModel[..., Any],
-                Tuple[Callable[..., Any], ...],
+                tuple[Callable[..., Any], ...],
             ],
         ] = {}
 
@@ -144,24 +131,21 @@ class CallModel(Generic[P, T]):
     def __init__(
         self,
         /,
-        call: Union[
-            Callable[P, T],
-            Callable[P, Awaitable[T]],
-        ],
-        model: Optional[Type[BaseModel]],
-        params: Dict[str, Tuple[Any, Any]],
-        response_model: Optional[Type[ResponseModel[T]]] = None,
+        call: Callable[P, T] | Callable[P, Awaitable[T]],
+        model: type[BaseModel] | None,
+        params: dict[str, tuple[Any, Any]],
+        response_model: type[ResponseModel[T]] | None = None,
         use_cache: bool = True,
         cast: bool = True,
         is_async: bool = False,
         is_generator: bool = False,
-        dependencies: Optional[Dict[str, "CallModel[..., Any]"]] = None,
-        extra_dependencies: Optional[Iterable["CallModel[..., Any]"]] = None,
-        keyword_args: Optional[List[str]] = None,
-        positional_args: Optional[List[str]] = None,
-        var_positional_arg: Optional[str] = None,
-        var_keyword_arg: Optional[str] = None,
-        custom_fields: Optional[Dict[str, CustomField]] = None,
+        dependencies: dict[str, "CallModel[..., Any]"] | None = None,
+        extra_dependencies: Iterable["CallModel[..., Any]"] | None = None,
+        keyword_args: list[str] | None = None,
+        positional_args: list[str] | None = None,
+        var_positional_arg: str | None = None,
+        var_keyword_arg: str | None = None,
+        custom_fields: dict[str, CustomField] | None = None,
     ):
         self.call = call
         self.model = model
@@ -185,7 +169,7 @@ class CallModel(Generic[P, T]):
         self.extra_dependencies = extra_dependencies or ()
         self.custom_fields = custom_fields or {}
 
-        sorted_dep: List[CallModel[..., Any]] = []
+        sorted_dep: list[CallModel[..., Any]] = []
         flat = self.flat_dependencies
         for calls in flat.values():
             _sort_dep(sorted_dep, calls, flat)
@@ -198,31 +182,20 @@ class CallModel(Generic[P, T]):
     def _solve(
         self,
         /,
-        *args: Tuple[Any, ...],
-        cache_dependencies: Dict[
-            Union[
-                Callable[P, T],
-                Callable[P, Awaitable[T]],
-            ],
+        *args: tuple[Any, ...],
+        cache_dependencies: dict[
+            Callable[P, T] | Callable[P, Awaitable[T]],
             T,
         ],
-        dependency_overrides: Optional[
-            Dict[
-                Union[
-                    Callable[P, T],
-                    Callable[P, Awaitable[T]],
-                ],
-                Union[
-                    Callable[P, T],
-                    Callable[P, Awaitable[T]],
-                ],
-            ]
-        ] = None,
-        **kwargs: Dict[str, Any],
+        dependency_overrides: dict[
+            Callable[P, T] | Callable[P, Awaitable[T]], Callable[P, T] | Callable[P, Awaitable[T]]
+        ]
+        | None = None,
+        **kwargs: dict[str, Any],
     ) -> Generator[
-        Tuple[
+        tuple[
             Sequence[Any],
-            Dict[str, Any],
+            dict[str, Any],
             Callable[..., Any],
         ],
         Any,
@@ -240,7 +213,7 @@ class CallModel(Generic[P, T]):
         if self.use_cache and call in cache_dependencies:
             return cache_dependencies[call]
 
-        kw: Dict[str, Any] = {}
+        kw: dict[str, Any] = {}
 
         for arg in self.keyword_args:
             if (v := kwargs.pop(arg, Parameter.empty)) is not Parameter.empty:
@@ -274,7 +247,7 @@ class CallModel(Generic[P, T]):
                 if arg not in self.dependencies:
                     kw[arg], args = args[0], args[1:]
 
-        solved_kw: Dict[str, Any]
+        solved_kw: dict[str, Any]
         solved_kw = yield args, kw, call
 
         args_: Sequence[Any]
@@ -319,25 +292,14 @@ class CallModel(Generic[P, T]):
         /,
         *args: Any,
         stack: ExitStack,
-        cache_dependencies: Dict[
-            Union[
-                Callable[P, T],
-                Callable[P, Awaitable[T]],
-            ],
+        cache_dependencies: dict[
+            Callable[P, T] | Callable[P, Awaitable[T]],
             T,
         ],
-        dependency_overrides: Optional[
-            Dict[
-                Union[
-                    Callable[P, T],
-                    Callable[P, Awaitable[T]],
-                ],
-                Union[
-                    Callable[P, T],
-                    Callable[P, Awaitable[T]],
-                ],
-            ]
-        ] = None,
+        dependency_overrides: dict[
+            Callable[P, T] | Callable[P, Awaitable[T]], Callable[P, T] | Callable[P, Awaitable[T]]
+        ]
+        | None = None,
         nested: bool = False,
         **kwargs: Any,
     ) -> T:
@@ -421,25 +383,14 @@ class CallModel(Generic[P, T]):
         /,
         *args: Any,
         stack: AsyncExitStack,
-        cache_dependencies: Dict[
-            Union[
-                Callable[P, T],
-                Callable[P, Awaitable[T]],
-            ],
+        cache_dependencies: dict[
+            Callable[P, T] | Callable[P, Awaitable[T]],
             T,
         ],
-        dependency_overrides: Optional[
-            Dict[
-                Union[
-                    Callable[P, T],
-                    Callable[P, Awaitable[T]],
-                ],
-                Union[
-                    Callable[P, T],
-                    Callable[P, Awaitable[T]],
-                ],
-            ]
-        ] = None,
+        dependency_overrides: dict[
+            Callable[P, T] | Callable[P, Awaitable[T]], Callable[P, T] | Callable[P, Awaitable[T]]
+        ]
+        | None = None,
         nested: bool = False,
         **kwargs: Any,
     ) -> T:
@@ -456,7 +407,7 @@ class CallModel(Generic[P, T]):
             return cached_value
 
         # Heat cache and solve extra dependencies
-        dep_to_solve: List[Callable[..., Awaitable[Any]]] = []
+        dep_to_solve: list[Callable[..., Awaitable[Any]]] = []
         try:
             async with anyio.create_task_group() as tg:
                 for dep, subdep in self.sorted_dependencies:
@@ -500,7 +451,7 @@ class CallModel(Generic[P, T]):
                 **kwargs,
             )
 
-        custom_to_solve: List[CustomField] = []
+        custom_to_solve: list[CustomField] = []
 
         try:
             async with anyio.create_task_group() as tg:
@@ -544,16 +495,16 @@ class CallModel(Generic[P, T]):
 
 
 def _sort_dep(
-    collector: List["CallModel[..., Any]"],
-    items: Tuple[
+    collector: list["CallModel[..., Any]"],
+    items: tuple[
         "CallModel[..., Any]",
-        Tuple[Callable[..., Any], ...],
+        tuple[Callable[..., Any], ...],
     ],
-    flat: Dict[
+    flat: dict[
         Callable[..., Any],
-        Tuple[
+        tuple[
             "CallModel[..., Any]",
-            Tuple[Callable[..., Any], ...],
+            tuple[Callable[..., Any], ...],
         ],
     ],
 ) -> None:

autogen/fast_depends/dependencies/model.py

@@ -5,7 +5,8 @@
 # Portions derived from  https://github.com/https://github.com/Lancetnik/FastDepends are under the MIT License.
 # SPDX-License-Identifier: MIT
 
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 
 class Depends:

autogen/fast_depends/dependencies/provider.py

@@ -5,12 +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 Callable, Iterator
 from contextlib import contextmanager
-from typing import Any, Callable, Dict, Iterator
+from typing import Any
 
 
 class Provider:
-    dependency_overrides: Dict[Callable[..., Any], Callable[..., Any]]
+    dependency_overrides: dict[Callable[..., Any], Callable[..., Any]]
 
     def __init__(self) -> None:
         self.dependency_overrides = {}