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

autogen/agents/experimental/reasoning/reasoning_agent.py

@@ -6,7 +6,7 @@ import math
 import random
 import re
 import warnings
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal, Optional
 
 from .... import Agent, AssistantAgent, UserProxyAgent
 from ....doc_utils import export_module
@@ -112,10 +112,10 @@ class ThinkNode:
         """
         self.content: str = content
         self.value: float = 0.0
-        self.parent: Optional[ThinkNode] = parent
+        self.parent: ThinkNode | None = parent
         self.reflection: str = ""
         self.rating_details: str = ""
-        self.output: Optional[str] = None
+        self.output: str | None = None
         self.depth: int = parent.depth + 1 if parent is not None else 0
         self.children: list[ThinkNode] = []
         self.visits: int = 0
@@ -156,7 +156,7 @@ class ThinkNode:
         Args:
             reward (float): The reward to backpropagate up the tree.
         """
-        node: Optional[ThinkNode] = self
+        node: ThinkNode | None = self
         while node is not None:
             node.visits += 1
             node.value = (node.value * (node.visits - 1) + reward) / node.visits
@@ -343,14 +343,14 @@ class ReasoningAgent(AssistantAgent):
     def __init__(
         self,
         name: str,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
-        grader_llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        grader_llm_config: LLMConfig | dict[str, Any] | None = None,
         max_depth: int = 4,
         beam_size: int = 3,
         answer_approach: Literal["pool", "best"] = "pool",
-        reason_config: Optional[dict[str, Any]] = None,
-        code_execution_config: Union[dict[str, Any], Literal[False]] = False,
-        scope: Optional[str] = None,
+        reason_config: dict[str, Any] | None = None,
+        code_execution_config: dict[str, Any] | Literal[False] = False,
+        scope: str | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize a ReasoningAgent that uses tree-of-thought reasoning.
@@ -428,8 +428,8 @@ class ReasoningAgent(AssistantAgent):
             code_execution_config=code_execution_config,
             **kwargs,
         )
-        self._llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = llm_config
-        self._grader_llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = (
+        self._llm_config: LLMConfig | dict[str, Any] | None = llm_config
+        self._grader_llm_config: LLMConfig | dict[str, Any] | None = (
             grader_llm_config if grader_llm_config else llm_config
         )
 
@@ -466,12 +466,12 @@ class ReasoningAgent(AssistantAgent):
         self._rating_scale: int = reason_config.get("rating_scale", 10)
         self._interim_execution: bool = reason_config.get("interim_execution", False)
 
-        self._root: Optional[ThinkNode] = None
+        self._root: ThinkNode | None = None
         self._lats_context: str = ""
         self.register_reply([Agent, None], ReasoningAgent.generate_forest_response)
 
         # Initialize llm agent for interim step execution
-        self._executor: Optional[AssistantAgent] = None
+        self._executor: AssistantAgent | None = None
         # Add scope if provided
         executor_msg = self._add_scope(EXECUTOR_MESSAGE)
         if self._interim_execution:
@@ -482,7 +482,7 @@ class ReasoningAgent(AssistantAgent):
         tot_msg = self._add_scope(TREEOFTHOUGHT_MESSAGE)
 
         # Initialize user proxy agent for code execution
-        self._user_proxy: Optional[UserProxyAgent] = None
+        self._user_proxy: UserProxyAgent | None = None
         if self._code_execution_config:
             # to execute code interim_execution should be True
             if not self._interim_execution:
@@ -525,9 +525,9 @@ class ReasoningAgent(AssistantAgent):
 
     def generate_forest_response(
         self,
-        messages: Optional[list[dict[str, Any]]] = None,
-        sender: Optional[Agent] = None,
-        config: Optional[dict[str, Any]] = None,
+        messages: list[dict[str, Any]] | None = None,
+        sender: Agent | None = None,
+        config: dict[str, Any] | None = None,
     ) -> tuple[bool, str]:
         """Generate a response using tree-of-thought reasoning.
 
@@ -574,12 +574,12 @@ Final Answer:
                 request_reply=True,
                 silent=self.silent,
             )
-            last_msg: Optional[dict[str, Any]] = self.last_message(self)
+            last_msg: dict[str, Any] | None = self.last_message(self)
             if last_msg is None:
                 return True, ""
             return True, last_msg["content"].strip()
 
-    def rate_node(self, node: ThinkNode, ground_truth: Optional[str] = None, is_outcome: bool = False) -> float:
+    def rate_node(self, node: ThinkNode, ground_truth: str | None = None, is_outcome: bool = False) -> float:
         """Rate the quality of a reasoning path or the final answer using the grader agent.
 
         Args:
@@ -663,7 +663,7 @@ Please provide your rating along with a brief explanation of your assessment.
             silent=self.silent,
         )
         rating: str = ""
-        last_message: Optional[dict[str, Any]] = self._grader.last_message()
+        last_message: dict[str, Any] | None = self._grader.last_message()
         if last_message is not None:
             rating = last_message["content"].strip()
         node.rating_details = rating
@@ -675,7 +675,7 @@ Please provide your rating along with a brief explanation of your assessment.
             reward = 0.0  # Default reward if parsing fails
         return reward
 
-    def rate_batch_nodes(self, nodes: list[ThinkNode], ground_truth: Optional[str] = None) -> list[float]:
+    def rate_batch_nodes(self, nodes: list[ThinkNode], ground_truth: str | None = None) -> list[float]:
         """Rate a batch of nodes using a single call of the grader agent. All the nodes must have the same parent.
 
         This method evaluates all given nodes while considering the other available options.
@@ -745,7 +745,7 @@ Rating: <rating>
             silent=self.silent,
         )
         rating: str = ""
-        last_message: Optional[dict[str, Any]] = self._grader.last_message()
+        last_message: dict[str, Any] | None = self._grader.last_message()
         if last_message is not None:
             rating = last_message["content"].strip()
 
@@ -772,7 +772,7 @@ Rating: <rating>
             rewards.append((float(rating) - 1.0) / (self._rating_scale - 1.0))
         return rewards
 
-    def execute_node(self, node: ThinkNode) -> Optional[str]:
+    def execute_node(self, node: ThinkNode) -> str | None:
         """Execute the node's content to get the response.
 
         This method runs the node's content to get the response.
@@ -805,7 +805,7 @@ Rating: <rating>
                 request_reply=True,
                 silent=self.silent,
             )
-            user_proxy_last_msg: Optional[dict[str, Any]] = self._user_proxy.last_message(self)
+            user_proxy_last_msg: dict[str, Any] | None = self._user_proxy.last_message(self)
             user_proxy_last_msg_content: str = user_proxy_last_msg["content"] if user_proxy_last_msg is not None else ""
             return user_proxy_last_msg_content
 
@@ -822,7 +822,7 @@ Rating: <rating>
         )
 
         output = ""
-        last_message: Optional[dict[str, Any]] = self._executor.last_message()
+        last_message: dict[str, Any] | None = self._executor.last_message()
 
         # this agent is not supposed to write Python code, so if there is a need for that ask the thinker to do so
         if last_message is not None:
@@ -836,8 +836,8 @@ Rating: <rating>
         return output
 
     def _process_prompt(
-        self, messages: Optional[list[dict[str, Any]]], sender: Optional[Agent]
-    ) -> tuple[Optional[str], Optional[str]]:
+        self, messages: list[dict[str, Any]] | None, sender: Agent | None
+    ) -> tuple[str | None, str | None]:
         """Process the incoming messages to extract the prompt and ground truth.
 
         This method checks if the provided messages are None and identifies the prompt.
@@ -892,7 +892,7 @@ CURRENT_QUESTION: *Write the current/last question to be addressed here. In case
                 request_reply=True,
                 silent=self.silent,
             )
-            last_msg: Optional[dict[str, Any]] = self._prompt_rewriter.last_message()
+            last_msg: dict[str, Any] | None = self._prompt_rewriter.last_message()
             prompt = last_msg["content"].strip() if last_msg is not None else ""
 
         if not prompt:
@@ -900,7 +900,7 @@ CURRENT_QUESTION: *Write the current/last question to be addressed here. In case
 
         return prompt, ground_truth
 
-    def _beam_reply(self, prompt: str, ground_truth: Optional[str] = None) -> str:
+    def _beam_reply(self, prompt: str, ground_truth: str | None = None) -> str:
         """Generate a response using tree-of-thought reasoning.
 
         Implements beam search through a tree of reasoning steps, using the thinker
@@ -993,11 +993,11 @@ Final Answer:
             request_reply=True,
             silent=self.silent,
         )
-        last_msg: Optional[dict[str, Any]] = self.last_message(self)
+        last_msg: dict[str, Any] | None = self.last_message(self)
         final_answer: str = last_msg["content"].strip() if last_msg is not None else ""
         return final_answer
 
-    def _mcts_reply(self, prompt: str, ground_truth: Optional[str] = None) -> str:
+    def _mcts_reply(self, prompt: str, ground_truth: str | None = None) -> str:
         """Generate a response using Monte Carlo Tree Search (MCTS) reasoning.
 
         Args:
@@ -1059,7 +1059,7 @@ Final Answer:
                 request_reply=True,
                 silent=self.silent,
             )
-            last_msg: Optional[dict[str, Any]] = self.last_message(self)
+            last_msg: dict[str, Any] | None = self.last_message(self)
             _answer: str = last_msg["content"].strip() if last_msg is not None else ""
             _ans_node = ThinkNode(content=_answer, parent=node)
             reward = self.rate_node(_ans_node, ground_truth, is_outcome=True)
@@ -1102,7 +1102,7 @@ Final Answer:
             request_reply=True,
             silent=self.silent,
         )
-        last_msg: Optional[dict[str, Any]] = self._thinker.last_message()
+        last_msg: dict[str, Any] | None = self._thinker.last_message()
         reply: str = last_msg["content"].strip() if last_msg is not None else ""
         reflection = re.findall(r"REFLECTION:\s*(.+?)(?=\*\*Possible Options:\*\*|Option \d+:|$)", reply, re.DOTALL)
         if reflection:

autogen/agents/experimental/slack/slack.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Optional
+from typing import Any
 
 from .... import ConversableAgent
 from ....doc_utils import export_module
@@ -24,7 +24,7 @@ class SlackAgent(ConversableAgent):
     def __init__(
         self,
         name: str,
-        system_message: Optional[str] = None,
+        system_message: str | None = None,
         *,
         bot_token: str,
         channel_id: str,

autogen/agents/experimental/telegram/telegram.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Optional
+from typing import Any
 
 from .... import ConversableAgent
 from ....doc_utils import export_module
@@ -24,7 +24,7 @@ class TelegramAgent(ConversableAgent):
     def __init__(
         self,
         name: str,
-        system_message: Optional[str] = None,
+        system_message: str | None = None,
         *,
         api_id: str,
         api_hash: str,
@@ -43,7 +43,6 @@ class TelegramAgent(ConversableAgent):
             has_writing_instructions (bool): Whether to add writing instructions to the system message. Defaults to True.
             **kwargs: Additional keyword arguments passed to the parent ConversableAgent class.
         """
-
         telegram_system_message = system_message or self.DEFAULT_SYSTEM_MESSAGE
 
         self._send_tool = TelegramSendTool(api_id=api_id, api_hash=api_hash, chat_id=chat_id)

autogen/agents/experimental/websurfer/websurfer.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from .... import ConversableAgent
 from ....doc_utils import export_module
@@ -28,12 +28,12 @@ class WebSurferAgent(ConversableAgent):
     def __init__(
         self,
         *,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
-        web_tool_llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        web_tool_llm_config: LLMConfig | dict[str, Any] | None = None,
         web_tool: Literal[
             "browser_use", "crawl4ai", "duckduckgo", "firecrawl", "perplexity", "tavily", "searxng"
         ] = "browser_use",
-        web_tool_kwargs: Optional[dict[str, Any]] = None,
+        web_tool_kwargs: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the WebSurferAgent.

autogen/agents/experimental/wikipedia/wikipedia.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, List, Optional, Union
+from typing import Any
 
 from .... import ConversableAgent
 from ....doc_utils import export_module
@@ -11,8 +11,7 @@ from ....tools.experimental import WikipediaPageLoadTool, WikipediaQueryRunTool
 
 @export_module("autogen.agents.experimental")
 class WikipediaAgent(ConversableAgent):
-    """
-    An AI agent that leverages Wikipedia tools to provide accurate, concise answers
+    """An AI agent that leverages Wikipedia tools to provide accurate, concise answers
     to user queries.
 
     Tools:
@@ -44,14 +43,13 @@ class WikipediaAgent(ConversableAgent):
 
     def __init__(
         self,
-        system_message: Optional[Union[str, List[str]]] = None,
-        format_instructions: Optional[str] = None,
+        system_message: str | list[str] | None = None,
+        format_instructions: str | None = None,
         language: str = "en",
         top_k: int = 2,
         **kwargs: Any,
     ) -> None:
-        """
-        Initialize the WikipediaAgent with optional custom prompts and tools.
+        """Initialize the WikipediaAgent with optional custom prompts and tools.
 
         Args:
             system_message (Optional[Union[str, List[str]]]):

autogen/browser_utils.py

@@ -10,7 +10,7 @@ import os
 import re
 import uuid
 from contextlib import suppress
-from typing import Any, Optional, Union
+from typing import Any
 from urllib.parse import urljoin, urlparse
 
 from .import_utils import optional_import_block, require_optional_import
@@ -38,12 +38,12 @@ class SimpleTextBrowser:
 
     def __init__(
         self,
-        start_page: Optional[str] = None,
-        viewport_size: Optional[int] = 1024 * 8,
-        downloads_folder: Optional[Union[str, None]] = None,
+        start_page: str | None = None,
+        viewport_size: int | None = 1024 * 8,
+        downloads_folder: str | None | None = None,
         bing_base_url: str = "https://api.bing.microsoft.com/v7.0/search",
-        bing_api_key: Optional[Union[str, None]] = None,
-        request_kwargs: Optional[Union[dict[str, Any], None]] = None,
+        bing_api_key: str | None | None = None,
+        request_kwargs: dict[str, Any] | None | None = None,
     ):
         """Initialize the browser with the given parameters.
 
@@ -59,7 +59,7 @@ class SimpleTextBrowser:
         self.viewport_size = viewport_size  # Applies only to the standard uri types
         self.downloads_folder = downloads_folder
         self.history: list[str] = list()
-        self.page_title: Optional[str] = None
+        self.page_title: str | None = None
         self.viewport_current_page = 0
         self.viewport_pages: list[tuple[int, int]] = list()
         self.set_address(self.start_page)
@@ -152,7 +152,7 @@ class SimpleTextBrowser:
             self.viewport_pages.append((start_idx, end_idx))
             start_idx = end_idx
 
-    def _bing_api_call(self, query: str) -> dict[str, dict[str, list[dict[str, Union[str, dict[str, str]]]]]]:
+    def _bing_api_call(self, query: str) -> dict[str, dict[str, list[dict[str, str | dict[str, str]]]]]:
         # Make sure the key was set
         if self.bing_api_key is None:
             raise ValueError("Missing Bing API key.")

autogen/cache/abstract_cache_base.py

@@ -6,7 +6,7 @@
 # SPDX-License-Identifier: MIT
 import sys
 from types import TracebackType
-from typing import Any, Optional, Protocol
+from typing import Any, Protocol
 
 from ..doc_utils import export_module
 
@@ -23,7 +23,7 @@ class AbstractCache(Protocol):
     these methods to handle caching mechanisms.
     """
 
-    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+    def get(self, key: str, default: Any | None = None) -> Any | None:
         """Retrieve an item from the cache.
 
         Args:
@@ -61,9 +61,9 @@ class AbstractCache(Protocol):
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         """Exit the runtime context and close the cache.
 

autogen/cache/cache.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 from contextvars import ContextVar
 from types import TracebackType
-from typing import Any, Optional, Union
+from typing import Any
 
 from ..doc_utils import export_module
 from .abstract_cache_base import AbstractCache
@@ -38,7 +38,7 @@ class Cache(AbstractCache):
     ]
 
     @staticmethod
-    def redis(cache_seed: Union[str, int] = 42, redis_url: str = "redis://localhost:6379/0") -> Cache:
+    def redis(cache_seed: str | int = 42, redis_url: str = "redis://localhost:6379/0") -> Cache:
         """Create a Redis cache instance.
 
         Args:
@@ -51,7 +51,7 @@ class Cache(AbstractCache):
         return Cache({"cache_seed": cache_seed, "redis_url": redis_url})
 
     @staticmethod
-    def disk(cache_seed: Union[str, int] = 42, cache_path_root: str = ".cache") -> Cache:
+    def disk(cache_seed: str | int = 42, cache_path_root: str = ".cache") -> Cache:
         """Create a Disk cache instance.
 
         Args:
@@ -65,10 +65,10 @@ class Cache(AbstractCache):
 
     @staticmethod
     def cosmos_db(
-        connection_string: Optional[str] = None,
-        container_id: Optional[str] = None,
-        cache_seed: Union[str, int] = 42,
-        client: Optional[Any] = None,
+        connection_string: str | None = None,
+        container_id: str | None = None,
+        cache_seed: str | int = 42,
+        client: Any | None = None,
     ) -> Cache:
         """Create a Cosmos DB cache instance with 'autogen_cache' as database ID.
 
@@ -131,9 +131,9 @@ class Cache(AbstractCache):
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         """Exit the runtime context related to the cache object.
 
@@ -159,7 +159,7 @@ class Cache(AbstractCache):
 
         return result
 
-    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+    def get(self, key: str, default: Any | None = None) -> Any | None:
         """Retrieve an item from the cache.
 
         Args:
@@ -189,7 +189,7 @@ class Cache(AbstractCache):
         self.cache.close()
 
     @classmethod
-    def get_current_cache(cls, cache: "Optional[Cache]" = None) -> "Optional[Cache]":
+    def get_current_cache(cls, cache: Cache | None = None) -> Cache | None:
         """Get the current cache instance.
 
         Returns:

autogen/cache/cache_factory.py

@@ -6,7 +6,7 @@
 # SPDX-License-Identifier: MIT
 import logging
 import os
-from typing import Any, Optional, Union
+from typing import Any
 
 from ..import_utils import optional_import_block
 from .abstract_cache_base import AbstractCache
@@ -16,10 +16,10 @@ from .disk_cache import DiskCache
 class CacheFactory:
     @staticmethod
     def cache_factory(
-        seed: Union[str, int],
-        redis_url: Optional[str] = None,
+        seed: str | int,
+        redis_url: str | None = None,
         cache_path_root: str = ".cache",
-        cosmosdb_config: Optional[dict[str, Any]] = None,
+        cosmosdb_config: dict[str, Any] | None = None,
     ) -> AbstractCache:
         """Factory function for creating cache instances.
 

autogen/cache/cosmos_db_cache.py

@@ -7,7 +7,7 @@
 # Install Azure Cosmos DB SDK if not already
 
 import pickle
-from typing import Any, Optional, TypedDict, Union
+from typing import Any, Optional, TypedDict
 
 from ..import_utils import optional_import_block, require_optional_import
 from .abstract_cache_base import AbstractCache
@@ -22,7 +22,7 @@ class CosmosDBConfig(TypedDict, total=False):
     connection_string: str
     database_id: str
     container_id: str
-    cache_seed: Optional[Union[str, int]]
+    cache_seed: str | int | None
     client: Optional["CosmosClient"]
 
 
@@ -39,7 +39,7 @@ class CosmosDBCache(AbstractCache):
         container: The container instance used for caching.
     """
 
-    def __init__(self, seed: Union[str, int], cosmosdb_config: CosmosDBConfig):
+    def __init__(self, seed: str | int, cosmosdb_config: CosmosDBConfig):
         """Initialize the CosmosDBCache instance.
 
         Args:
@@ -58,7 +58,7 @@ class CosmosDBCache(AbstractCache):
         )
 
     @classmethod
-    def create_cache(cls, seed: Union[str, int], cosmosdb_config: CosmosDBConfig):
+    def create_cache(cls, seed: str | int, cosmosdb_config: CosmosDBConfig):
         """Factory method to create a CosmosDBCache instance based on the provided configuration.
         This method decides whether to use an existing CosmosClient or create a new one.
         """
@@ -68,20 +68,20 @@ class CosmosDBCache(AbstractCache):
             return cls.from_config(seed, cosmosdb_config)
 
     @classmethod
-    def from_config(cls, seed: Union[str, int], cosmosdb_config: CosmosDBConfig):
+    def from_config(cls, seed: str | int, cosmosdb_config: CosmosDBConfig):
         return cls(str(seed), cosmosdb_config)
 
     @classmethod
-    def from_connection_string(cls, seed: Union[str, int], connection_string: str, database_id: str, container_id: str):
+    def from_connection_string(cls, seed: str | int, connection_string: str, database_id: str, container_id: str):
         config = {"connection_string": connection_string, "database_id": database_id, "container_id": container_id}
         return cls(str(seed), config)
 
     @classmethod
-    def from_existing_client(cls, seed: Union[str, int], client: "CosmosClient", database_id: str, container_id: str):
+    def from_existing_client(cls, seed: str | int, client: "CosmosClient", database_id: str, container_id: str):
         config = {"client": client, "database_id": database_id, "container_id": container_id}
         return cls(str(seed), config)
 
-    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+    def get(self, key: str, default: Any | None = None) -> Any | None:
         """Retrieve an item from the Cosmos DB cache.
 
         Args:
@@ -136,7 +136,7 @@ class CosmosDBCache(AbstractCache):
         """
         return self
 
-    def __exit__(self, exc_type: Optional[type], exc_value: Optional[Exception], traceback: Optional[Any]) -> None:
+    def __exit__(self, exc_type: type | None, exc_value: Exception | None, traceback: Any | None) -> None:
         """Context management exit.
 
         Perform cleanup actions such as closing the Cosmos DB client.

autogen/cache/disk_cache.py

@@ -6,7 +6,7 @@
 # SPDX-License-Identifier: MIT
 import sys
 from types import TracebackType
-from typing import Any, Optional, Union
+from typing import Any
 
 import diskcache
 
@@ -36,7 +36,7 @@ class DiskCache(AbstractCache):
         __exit__(self, exc_type, exc_value, traceback): Context management exit.
     """
 
-    def __init__(self, seed: Union[str, int]):
+    def __init__(self, seed: str | int):
         """Initialize the DiskCache instance.
 
         Args:
@@ -46,7 +46,7 @@ class DiskCache(AbstractCache):
         """
         self.cache = diskcache.Cache(seed)
 
-    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+    def get(self, key: str, default: Any | None = None) -> Any | None:
         """Retrieve an item from the cache.
 
         Args:
@@ -86,9 +86,9 @@ class DiskCache(AbstractCache):
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         """Exit the runtime context related to the object.
 

autogen/cache/in_memory_cache.py

@@ -6,7 +6,7 @@
 # SPDX-License-Identifier: MIT
 import sys
 from types import TracebackType
-from typing import Any, Optional, Union
+from typing import Any
 
 from .abstract_cache_base import AbstractCache
 
@@ -17,7 +17,7 @@ else:
 
 
 class InMemoryCache(AbstractCache):
-    def __init__(self, seed: Union[str, int] = ""):
+    def __init__(self, seed: str | int = ""):
         self._seed = str(seed)
         self._cache: dict[str, Any] = {}
 
@@ -25,7 +25,7 @@ class InMemoryCache(AbstractCache):
         separator = "_" if self._seed else ""
         return f"{self._seed}{separator}{key}"
 
-    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+    def get(self, key: str, default: Any | None = None) -> Any | None:
         result = self._cache.get(self._prefixed_key(key))
         if result is None:
             return default
@@ -46,7 +46,7 @@ class InMemoryCache(AbstractCache):
         return self
 
     def __exit__(
-        self, exc_type: Optional[type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None:
         """Exit the runtime context related to the object.