ag2 0.10.2__py3-none-any.whl

autogen/fast_depends/schema.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/https://github.com/Lancetnik/FastDepends are under the MIT License.
+# SPDX-License-Identifier: MIT
+
+from typing import Any
+
+from ._compat import PYDANTIC_V2, create_model, model_schema
+from .core import CallModel
+
+
+def get_schema(
+    call: CallModel[Any, Any],
+    embed: bool = False,
+    resolve_refs: bool = False,
+) -> 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)
+
+    if not call.flat_params:
+        body = {"title": body["title"], "type": "null"}
+
+    if resolve_refs:
+        pydantic_key = "$defs" if PYDANTIC_V2 else "definitions"
+        body = _move_pydantic_refs(body, pydantic_key)
+        body.pop(pydantic_key, None)
+
+    if embed and len(body["properties"]) == 1:
+        body = list(body["properties"].values())[0]
+
+    return body
+
+
+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()
+
+    if refs is None:
+        raw_refs = data.get(key, {})
+        refs = _move_pydantic_refs(raw_refs, key, raw_refs)
+
+    name: str | None = None
+    for k in data:
+        if k == "$ref":
+            name = data[k].replace(f"#/{key}/", "")
+
+        elif isinstance(data[k], dict):
+            data[k] = _move_pydantic_refs(data[k], key, refs)
+
+        elif isinstance(data[k], list):
+            for i in range(len(data[k])):
+                data[k][i] = _move_pydantic_refs(data[k][i], key, refs)
+
+    if name:
+        assert refs, "Smth wrong"
+        data = refs[name]
+
+    return data

autogen/fast_depends/use.py

@@ -0,0 +1,272 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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,
+    Protocol,
+    TypeVar,
+    cast,
+    overload,
+)
+
+from typing_extensions import ParamSpec
+
+from ._compat import ConfigDict
+from .core import CallModel, build_call_model
+from .dependencies import dependency_provider, model
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def Depends(  # noqa: N802
+    dependency: Callable[P, T],
+    *,
+    use_cache: bool = True,
+    cast: bool = True,
+) -> Any:
+    return model.Depends(
+        dependency=dependency,
+        use_cache=use_cache,
+        cast=cast,
+    )
+
+
+class _InjectWrapper(Protocol[P, T]):
+    def __call__(
+        self,
+        func: Callable[P, T],
+        model: CallModel[P, T] | None = None,
+    ) -> Callable[P, T]: ...
+
+
+@overload
+def inject(  # pragma: no cover
+    func: None,
+    *,
+    cast: bool = True,
+    extra_dependencies: Sequence[model.Depends] = (),
+    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]: ...
+
+
+@overload
+def inject(  # pragma: no cover
+    func: Callable[P, T],
+    *,
+    cast: bool = True,
+    extra_dependencies: Sequence[model.Depends] = (),
+    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: Callable[P, T] | None = None,
+    *,
+    cast: bool = True,
+    extra_dependencies: Sequence[model.Depends] = (),
+    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] | _InjectWrapper[P, T]:
+    decorator = _wrap_inject(
+        dependency_overrides_provider=dependency_overrides_provider,
+        wrap_model=wrap_model,
+        extra_dependencies=extra_dependencies,
+        cast=cast,
+        pydantic_config=pydantic_config,
+    )
+
+    if func is None:
+        return decorator
+
+    else:
+        return decorator(func)
+
+
+def _wrap_inject(
+    dependency_overrides_provider: Any | None,
+    wrap_model: Callable[
+        [CallModel[P, T]],
+        CallModel[P, T],
+    ],
+    extra_dependencies: Sequence[model.Depends],
+    cast: bool,
+    pydantic_config: ConfigDict | None,
+) -> _InjectWrapper[P, T]:
+    if (
+        dependency_overrides_provider
+        and getattr(dependency_overrides_provider, "dependency_overrides", None) is not None
+    ):
+        overrides = dependency_overrides_provider.dependency_overrides
+    else:
+        overrides = None
+
+    def func_wrapper(
+        func: Callable[P, T],
+        model: CallModel[P, T] | None = None,
+    ) -> Callable[P, T]:
+        if model is None:
+            real_model = wrap_model(
+                build_call_model(
+                    call=func,
+                    extra_dependencies=extra_dependencies,
+                    cast=cast,
+                    pydantic_config=pydantic_config,
+                )
+            )
+        else:
+            real_model = model
+
+        if real_model.is_async:
+            injected_wrapper: Callable[P, T]
+
+            if real_model.is_generator:
+                injected_wrapper = partial(solve_async_gen, real_model, overrides)  # type: ignore[assignment]
+
+            else:
+
+                @wraps(func)
+                async def injected_wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+                    async with AsyncExitStack() as stack:
+                        r = await real_model.asolve(
+                            *args,
+                            stack=stack,
+                            dependency_overrides=overrides,
+                            cache_dependencies={},
+                            nested=False,
+                            **kwargs,
+                        )
+                        return r
+
+                    raise AssertionError("unreachable")
+
+        else:
+            if real_model.is_generator:
+                injected_wrapper = partial(solve_gen, real_model, overrides)  # type: ignore[assignment]
+
+            else:
+
+                @wraps(func)
+                def injected_wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+                    with ExitStack() as stack:
+                        r = real_model.solve(
+                            *args,
+                            stack=stack,
+                            dependency_overrides=overrides,
+                            cache_dependencies={},
+                            nested=False,
+                            **kwargs,
+                        )
+                        return r
+
+                    raise AssertionError("unreachable")
+
+        return injected_wrapper
+
+    return func_wrapper
+
+
+class solve_async_gen:  # noqa: N801
+    _iter: AsyncIterator[Any] | None = None
+
+    def __init__(
+        self,
+        model: "CallModel[..., Any]",
+        overrides: Any | None,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        self.call = model
+        self.args = args
+        self.kwargs = kwargs
+        self.overrides = overrides
+
+    def __aiter__(self) -> "solve_async_gen":
+        self._iter = None
+        self.stack = AsyncExitStack()
+        return self
+
+    async def __anext__(self) -> Any:
+        if self._iter is None:
+            stack = self.stack = AsyncExitStack()
+            await self.stack.__aenter__()
+            self._iter = cast(
+                AsyncIterator[Any],
+                (
+                    await self.call.asolve(
+                        *self.args,
+                        stack=stack,
+                        dependency_overrides=self.overrides,
+                        cache_dependencies={},
+                        nested=False,
+                        **self.kwargs,
+                    )
+                ).__aiter__(),
+            )
+
+        try:
+            r = await self._iter.__anext__()
+        except StopAsyncIteration as e:
+            await self.stack.__aexit__(None, None, None)
+            raise e
+        else:
+            return r
+
+
+class solve_gen:  # noqa: N801
+    _iter: Iterator[Any] | None = None
+
+    def __init__(
+        self,
+        model: "CallModel[..., Any]",
+        overrides: Any | None,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        self.call = model
+        self.args = args
+        self.kwargs = kwargs
+        self.overrides = overrides
+
+    def __iter__(self) -> "solve_gen":
+        self._iter = None
+        self.stack = ExitStack()
+        return self
+
+    def __next__(self) -> Any:
+        if self._iter is None:
+            stack = self.stack = ExitStack()
+            self.stack.__enter__()
+            self._iter = cast(
+                Iterator[Any],
+                iter(
+                    self.call.solve(
+                        *self.args,
+                        stack=stack,
+                        dependency_overrides=self.overrides,
+                        cache_dependencies={},
+                        nested=False,
+                        **self.kwargs,
+                    )
+                ),
+            )
+
+        try:
+            r = next(self._iter)
+        except StopIteration as e:
+            self.stack.__exit__(None, None, None)
+            raise e
+        else:
+            return r

autogen/fast_depends/utils.py

@@ -0,0 +1,177 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/https://github.com/Lancetnik/FastDepends are under the MIT License.
+# SPDX-License-Identifier: MIT
+
+import asyncio
+import functools
+import inspect
+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 (
+    ParamSpec,
+)
+
+from ._compat import evaluate_forwardref
+
+if TYPE_CHECKING:
+    from types import FrameType
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def asyncify(func: Callable[P, T]) -> Callable[P, Awaitable[T]]:
+    if is_coroutine_callable(func):
+        return cast(Callable[P, Awaitable[T]], func)
+
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        return await run_in_threadpool(func, *args, **kwargs)
+
+    return wrapper
+
+
+async def run_async(
+    func: Callable[P, T] | Callable[P, Awaitable[T]],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> T:
+    if is_coroutine_callable(func):
+        return await cast(Callable[P, Awaitable[T]], func)(*args, **kwargs)
+    else:
+        return await run_in_threadpool(cast(Callable[P, T], func), *args, **kwargs)
+
+
+async def run_in_threadpool(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    if kwargs:
+        func = functools.partial(func, **kwargs)
+    return await anyio.to_thread.run_sync(func, *args)
+
+
+async def solve_generator_async(
+    *sub_args: Any, call: Callable[..., Any], stack: AsyncExitStack, **sub_values: Any
+) -> Any:
+    if is_gen_callable(call):
+        cm = contextmanager_in_threadpool(contextmanager(call)(**sub_values))
+    elif is_async_gen_callable(call):  # pragma: no branch
+        cm = asynccontextmanager(call)(*sub_args, **sub_values)
+    return await stack.enter_async_context(cm)
+
+
+def solve_generator_sync(*sub_args: Any, call: Callable[..., Any], stack: ExitStack, **sub_values: Any) -> Any:
+    cm = contextmanager(call)(*sub_args, **sub_values)
+    return stack.enter_context(cm)
+
+
+def get_typed_signature(call: Callable[..., Any]) -> tuple[inspect.Signature, Any]:
+    signature = inspect.signature(call)
+
+    locals = collect_outer_stack_locals()
+
+    # We unwrap call to get the original unwrapped function
+    call = inspect.unwrap(call)
+
+    globalns = getattr(call, "__globals__", {})
+    typed_params = [
+        inspect.Parameter(
+            name=param.name,
+            kind=param.kind,
+            default=param.default,
+            annotation=get_typed_annotation(
+                param.annotation,
+                globalns,
+                locals,
+            ),
+        )
+        for param in signature.parameters.values()
+    ]
+
+    return inspect.Signature(typed_params), get_typed_annotation(
+        signature.return_annotation,
+        globalns,
+        locals,
+    )
+
+
+def collect_outer_stack_locals() -> dict[str, Any]:
+    frame = inspect.currentframe()
+
+    frames: list[FrameType] = []
+    while frame is not None:
+        if "fast_depends" not in frame.f_code.co_filename:
+            frames.append(frame)
+        frame = frame.f_back
+
+    locals = {}
+    for f in frames[::-1]:
+        locals.update(f.f_locals)
+
+    return locals
+
+
+def get_typed_annotation(
+    annotation: Any,
+    globalns: dict[str, Any],
+    locals: dict[str, Any],
+) -> Any:
+    if isinstance(annotation, str):
+        annotation = ForwardRef(annotation)
+
+    if isinstance(annotation, ForwardRef):
+        annotation = evaluate_forwardref(annotation, globalns, locals)
+
+    if get_origin(annotation) is Annotated and (args := get_args(annotation)):
+        solved_args = [get_typed_annotation(x, globalns, locals) for x in args]
+        annotation.__origin__, annotation.__metadata__ = solved_args[0], tuple(solved_args[1:])
+
+    return annotation
+
+
+@asynccontextmanager
+async def contextmanager_in_threadpool(
+    cm: AbstractContextManager[T],
+) -> AsyncGenerator[T, None]:
+    exit_limiter = anyio.CapacityLimiter(1)
+    try:
+        yield await run_in_threadpool(cm.__enter__)
+    except Exception as e:
+        ok = bool(await anyio.to_thread.run_sync(cm.__exit__, type(e), e, None, limiter=exit_limiter))
+        if not ok:  # pragma: no branch
+            raise e
+    else:
+        await anyio.to_thread.run_sync(cm.__exit__, None, None, None, limiter=exit_limiter)
+
+
+def is_gen_callable(call: Callable[..., Any]) -> bool:
+    if inspect.isgeneratorfunction(call):
+        return True
+    dunder_call = getattr(call, "__call__", None)  # noqa: B004
+    return inspect.isgeneratorfunction(dunder_call)
+
+
+def is_async_gen_callable(call: Callable[..., Any]) -> bool:
+    if inspect.isasyncgenfunction(call):
+        return True
+    dunder_call = getattr(call, "__call__", None)  # noqa: B004
+    return inspect.isasyncgenfunction(dunder_call)
+
+
+def is_coroutine_callable(call: Callable[..., Any]) -> bool:
+    if inspect.isclass(call):
+        return False
+
+    if asyncio.iscoroutinefunction(call):
+        return True
+
+    dunder_call = getattr(call, "__call__", None)  # noqa: B004
+    return asyncio.iscoroutinefunction(dunder_call)
+
+
+async def async_map(func: Callable[..., T], async_iterable: AsyncIterable[Any]) -> AsyncIterable[T]:
+    async for i in async_iterable:
+        yield func(i)

autogen/formatting_utils.py

@@ -0,0 +1,83 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Literal
+
+from .import_utils import optional_import_block
+
+with optional_import_block() as result:
+    from termcolor import colored
+
+if not result.is_successful:
+    # termcolor is an optional dependency - if it cannot be imported then no color is used.
+    # Alternatively the envvar NO_COLOR can be used to disable color.
+    # To allow for proper typing and for termcolor to be optional we need to re-define the types used in the lib here.
+    # This is the direct function definition from termcolor.
+    Attribute = Literal[
+        "bold",
+        "dark",
+        "underline",
+        "blink",
+        "reverse",
+        "concealed",
+    ]
+
+    Highlight = Literal[
+        "on_black",
+        "on_grey",
+        "on_red",
+        "on_green",
+        "on_yellow",
+        "on_blue",
+        "on_magenta",
+        "on_cyan",
+        "on_light_grey",
+        "on_dark_grey",
+        "on_light_red",
+        "on_light_green",
+        "on_light_yellow",
+        "on_light_blue",
+        "on_light_magenta",
+        "on_light_cyan",
+        "on_white",
+    ]
+
+    Color = Literal[
+        "black",
+        "grey",
+        "red",
+        "green",
+        "yellow",
+        "blue",
+        "magenta",
+        "cyan",
+        "light_grey",
+        "dark_grey",
+        "light_red",
+        "light_green",
+        "light_yellow",
+        "light_blue",
+        "light_magenta",
+        "light_cyan",
+        "white",
+    ]
+
+    def colored(
+        text: object,
+        color: Color | None = None,
+        on_color: Highlight | None = None,
+        attrs: Iterable[Attribute] | None = None,
+        *,
+        no_color: bool | None = None,
+        force_color: bool | None = None,
+    ) -> str:
+        return str(text)
+
+
+__all__ = ["colored"]

autogen/function_utils.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from logging import getLogger
+
+from .tools import get_function_schema, load_basemodels_if_needed, serialize_to_str
+
+__all__ = ["get_function_schema", "load_basemodels_if_needed", "serialize_to_str"]
+
+logger = getLogger(__name__)
+
+logger.info("Importing from 'autogen.function_utils' is deprecated, import from 'autogen.tools' instead.")