ag2 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

autogen/agentchat/user_proxy_agent.py

@@ -1,109 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-from typing import Callable, Dict, List, Literal, Optional, Union
-
-from ..runtime_logging import log_new_agent, logging_enabled
-from .conversable_agent import ConversableAgent
-
-
-class UserProxyAgent(ConversableAgent):
-    """(In preview) A proxy agent for the user, that can execute code and provide feedback to the other agents.
-
-    UserProxyAgent is a subclass of ConversableAgent configured with `human_input_mode` to ALWAYS
-    and `llm_config` to False. By default, the agent will prompt for human input every time a message is received.
-    Code execution is enabled by default. LLM-based auto reply is disabled by default.
-    To modify auto reply, register a method with [`register_reply`](conversable_agent#register_reply).
-    To modify the way to get human input, override `get_human_input` method.
-    To modify the way to execute code blocks, single code block, or function call, override `execute_code_blocks`,
-    `run_code`, and `execute_function` methods respectively.
-    """
-
-    # Default UserProxyAgent.description values, based on human_input_mode
-    DEFAULT_USER_PROXY_AGENT_DESCRIPTIONS = {
-        "ALWAYS": "An attentive HUMAN user who can answer questions about the task, and can perform tasks such as running Python code or inputting command line commands at a Linux terminal and reporting back the execution results.",
-        "TERMINATE": "A user that can run Python code or input command line commands at a Linux terminal and report back the execution results.",
-        "NEVER": "A computer terminal that performs no other action than running Python scripts (provided to it quoted in ```python code blocks), or sh shell scripts (provided to it quoted in ```sh code blocks).",
-    }
-
-    def __init__(
-        self,
-        name: str,
-        is_termination_msg: Optional[Callable[[Dict], bool]] = None,
-        max_consecutive_auto_reply: Optional[int] = None,
-        human_input_mode: Literal["ALWAYS", "TERMINATE", "NEVER"] = "ALWAYS",
-        function_map: Optional[Dict[str, Callable]] = None,
-        code_execution_config: Union[Dict, Literal[False]] = {},
-        default_auto_reply: Optional[Union[str, Dict, None]] = "",
-        llm_config: Optional[Union[Dict, Literal[False]]] = False,
-        system_message: Optional[Union[str, List]] = "",
-        description: Optional[str] = None,
-        **kwargs,
-    ):
-        """
-        Args:
-            name (str): name of the agent.
-            is_termination_msg (function): a function that takes a message in the form of a dictionary
-                and returns a boolean value indicating if this received message is a termination message.
-                The dict can contain the following keys: "content", "role", "name", "function_call".
-            max_consecutive_auto_reply (int): the maximum number of consecutive auto replies.
-                default to None (no limit provided, class attribute MAX_CONSECUTIVE_AUTO_REPLY will be used as the limit in this case).
-                The limit only plays a role when human_input_mode is not "ALWAYS".
-            human_input_mode (str): whether to ask for human inputs every time a message is received.
-                Possible values are "ALWAYS", "TERMINATE", "NEVER".
-                (1) When "ALWAYS", the agent prompts for human input every time a message is received.
-                    Under this mode, the conversation stops when the human input is "exit",
-                    or when is_termination_msg is True and there is no human input.
-                (2) When "TERMINATE", the agent only prompts for human input only when a termination message is received or
-                    the number of auto reply reaches the max_consecutive_auto_reply.
-                (3) When "NEVER", the agent will never prompt for human input. Under this mode, the conversation stops
-                    when the number of auto reply reaches the max_consecutive_auto_reply or when is_termination_msg is True.
-            function_map (dict[str, callable]): Mapping function names (passed to openai) to callable functions.
-            code_execution_config (dict or False): config for the code execution.
-                To disable code execution, set to False. Otherwise, set to a dictionary with the following keys:
-                - work_dir (Optional, str): The working directory for the code execution.
-                    If None, a default working directory will be used.
-                    The default working directory is the "extensions" directory under
-                    "path_to_autogen".
-                - use_docker (Optional, list, str or bool): The docker image to use for code execution.
-                    Default is True, which means the code will be executed in a docker container. A default list of images will be used.
-                    If a list or a str of image name(s) is provided, the code will be executed in a docker container
-                    with the first image successfully pulled.
-                    If False, the code will be executed in the current environment.
-                    We strongly recommend using docker for code execution.
-                - timeout (Optional, int): The maximum execution time in seconds.
-                - last_n_messages (Experimental, Optional, int): The number of messages to look back for code execution. Default to 1.
-            default_auto_reply (str or dict or None): the default auto reply message when no code execution or llm based reply is generated.
-            llm_config (dict or False or None): llm inference configuration.
-                Please refer to [OpenAIWrapper.create](/docs/reference/oai/client#create)
-                for available options.
-                Default to False, which disables llm-based auto reply.
-                When set to None, will use self.DEFAULT_CONFIG, which defaults to False.
-            system_message (str or List): system message for ChatCompletion inference.
-                Only used when llm_config is not False. Use it to reprogram the agent.
-            description (str): a short description of the agent. This description is used by other agents
-                (e.g. the GroupChatManager) to decide when to call upon this agent. (Default: system_message)
-            **kwargs (dict): Please refer to other kwargs in
-                [ConversableAgent](conversable_agent#__init__).
-        """
-        super().__init__(
-            name=name,
-            system_message=system_message,
-            is_termination_msg=is_termination_msg,
-            max_consecutive_auto_reply=max_consecutive_auto_reply,
-            human_input_mode=human_input_mode,
-            function_map=function_map,
-            code_execution_config=code_execution_config,
-            llm_config=llm_config,
-            default_auto_reply=default_auto_reply,
-            description=(
-                description if description is not None else self.DEFAULT_USER_PROXY_AGENT_DESCRIPTIONS[human_input_mode]
-            ),
-            **kwargs,
-        )
-
-        if logging_enabled():
-            log_new_agent(self, locals())

autogen/agentchat/utils.py

@@ -1,207 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-import re
-from typing import Any, Callable, Dict, List, Union
-
-from .agent import Agent
-
-
-def consolidate_chat_info(chat_info, uniform_sender=None) -> None:
-    if isinstance(chat_info, dict):
-        chat_info = [chat_info]
-    for c in chat_info:
-        if uniform_sender is None:
-            assert "sender" in c, "sender must be provided."
-            sender = c["sender"]
-        else:
-            sender = uniform_sender
-        assert "recipient" in c, "recipient must be provided."
-        summary_method = c.get("summary_method")
-        assert (
-            summary_method is None
-            or isinstance(summary_method, Callable)
-            or summary_method in ("last_msg", "reflection_with_llm")
-        ), "summary_method must be a string chosen from 'reflection_with_llm' or 'last_msg' or a callable, or None."
-        if summary_method == "reflection_with_llm":
-            assert (
-                sender.client is not None or c["recipient"].client is not None
-            ), "llm client must be set in either the recipient or sender when summary_method is reflection_with_llm."
-
-
-def gather_usage_summary(agents: List[Agent]) -> Dict[Dict[str, Dict], Dict[str, Dict]]:
-    r"""Gather usage summary from all agents.
-
-    Args:
-        agents: (list): List of agents.
-
-    Returns:
-        dictionary: A dictionary containing two keys:
-          - "usage_including_cached_inference": Cost information on the total usage, including the tokens in cached inference.
-          - "usage_excluding_cached_inference": Cost information on the usage of tokens, excluding the tokens in cache. No larger than "usage_including_cached_inference".
-
-    Example:
-
-    ```python
-    {
-        "usage_including_cached_inference" : {
-            "total_cost": 0.0006090000000000001,
-            "gpt-35-turbo": {
-                    "cost": 0.0006090000000000001,
-                    "prompt_tokens": 242,
-                    "completion_tokens": 123,
-                    "total_tokens": 365
-            },
-        },
-
-        "usage_excluding_cached_inference" : {
-            "total_cost": 0.0006090000000000001,
-            "gpt-35-turbo": {
-                    "cost": 0.0006090000000000001,
-                    "prompt_tokens": 242,
-                    "completion_tokens": 123,
-                    "total_tokens": 365
-            },
-        }
-    }
-    ```
-
-    Note:
-
-    If none of the agents incurred any cost (not having a client), then the usage_including_cached_inference and usage_excluding_cached_inference will be `{'total_cost': 0}`.
-    """
-
-    def aggregate_summary(usage_summary: Dict[str, Any], agent_summary: Dict[str, Any]) -> None:
-        if agent_summary is None:
-            return
-        usage_summary["total_cost"] += agent_summary.get("total_cost", 0)
-        for model, data in agent_summary.items():
-            if model != "total_cost":
-                if model not in usage_summary:
-                    usage_summary[model] = data.copy()
-                else:
-                    usage_summary[model]["cost"] += data.get("cost", 0)
-                    usage_summary[model]["prompt_tokens"] += data.get("prompt_tokens", 0)
-                    usage_summary[model]["completion_tokens"] += data.get("completion_tokens", 0)
-                    usage_summary[model]["total_tokens"] += data.get("total_tokens", 0)
-
-    usage_including_cached_inference = {"total_cost": 0}
-    usage_excluding_cached_inference = {"total_cost": 0}
-
-    for agent in agents:
-        if getattr(agent, "client", None):
-            aggregate_summary(usage_including_cached_inference, agent.client.total_usage_summary)
-            aggregate_summary(usage_excluding_cached_inference, agent.client.actual_usage_summary)
-
-    return {
-        "usage_including_cached_inference": usage_including_cached_inference,
-        "usage_excluding_cached_inference": usage_excluding_cached_inference,
-    }
-
-
-def parse_tags_from_content(tag: str, content: Union[str, List[Dict[str, Any]]]) -> List[Dict[str, Dict[str, str]]]:
-    """Parses HTML style tags from message contents.
-
-    The parsing is done by looking for patterns in the text that match the format of HTML tags. The tag to be parsed is
-    specified as an argument to the function. The function looks for this tag in the text and extracts its content. The
-    content of a tag is everything that is inside the tag, between the opening and closing angle brackets. The content
-    can be a single string or a set of attribute-value pairs.
-
-    Examples:
-        <img http://example.com/image.png> -> [{"tag": "img", "attr": {"src": "http://example.com/image.png"}, "match": re.Match}]
-        <audio text="Hello I'm a robot" prompt="whisper"> ->
-                [{"tag": "audio", "attr": {"text": "Hello I'm a robot", "prompt": "whisper"}, "match": re.Match}]
-
-    Args:
-        tag (str): The HTML style tag to be parsed.
-        content (Union[str, List[Dict[str, Any]]]): The message content to parse. Can be a string or a list of content
-            items.
-
-    Returns:
-        List[Dict[str, str]]: A list of dictionaries, where each dictionary represents a parsed tag. Each dictionary
-            contains three key-value pairs: 'type' which is the tag, 'attr' which is a dictionary of the parsed attributes,
-            and 'match' which is a regular expression match object.
-
-    Raises:
-        ValueError: If the content is not a string or a list.
-    """
-    results = []
-    if isinstance(content, str):
-        results.extend(_parse_tags_from_text(tag, content))
-    # Handles case for multimodal messages.
-    elif isinstance(content, list):
-        for item in content:
-            if item.get("type") == "text":
-                results.extend(_parse_tags_from_text(tag, item["text"]))
-    else:
-        raise ValueError(f"content must be str or list, but got {type(content)}")
-
-    return results
-
-
-def _parse_tags_from_text(tag: str, text: str) -> List[Dict[str, str]]:
-    pattern = re.compile(f"<{tag} (.*?)>")
-
-    results = []
-    for match in re.finditer(pattern, text):
-        tag_attr = match.group(1).strip()
-        attr = _parse_attributes_from_tags(tag_attr)
-
-        results.append({"tag": tag, "attr": attr, "match": match})
-    return results
-
-
-def _parse_attributes_from_tags(tag_content: str):
-    pattern = r"([^ ]+)"
-    attrs = re.findall(pattern, tag_content)
-    reconstructed_attrs = _reconstruct_attributes(attrs)
-
-    def _append_src_value(content, value):
-        if "src" in content:
-            content["src"] += f" {value}"
-        else:
-            content["src"] = value
-
-    content = {}
-    for attr in reconstructed_attrs:
-        if "=" not in attr:
-            _append_src_value(content, attr)
-            continue
-
-        key, value = attr.split("=", 1)
-        if value.startswith("'") or value.startswith('"'):
-            content[key] = value[1:-1]  # remove quotes
-        else:
-            _append_src_value(content, attr)
-
-    return content
-
-
-def _reconstruct_attributes(attrs: List[str]) -> List[str]:
-    """Reconstructs attributes from a list of strings where some attributes may be split across multiple elements."""
-
-    def is_attr(attr: str) -> bool:
-        if "=" in attr:
-            _, value = attr.split("=", 1)
-            if value.startswith("'") or value.startswith('"'):
-                return True
-        return False
-
-    reconstructed = []
-    found_attr = False
-    for attr in attrs:
-        if is_attr(attr):
-            reconstructed.append(attr)
-            found_attr = True
-        else:
-            if found_attr:
-                reconstructed[-1] += f" {attr}"
-                found_attr = True
-            elif reconstructed:
-                reconstructed[-1] += f" {attr}"
-            else:
-                reconstructed.append(attr)
-    return reconstructed

autogen/browser_utils.py

@@ -1,291 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-import io
-import json
-import mimetypes
-import os
-import re
-import uuid
-from typing import Any, Dict, List, Optional, Tuple, Union
-from urllib.parse import urljoin, urlparse
-
-import markdownify
-import requests
-from bs4 import BeautifulSoup
-
-# Optional PDF support
-IS_PDF_CAPABLE = False
-try:
-    import pdfminer
-    import pdfminer.high_level
-
-    IS_PDF_CAPABLE = True
-except ModuleNotFoundError:
-    pass
-
-# Other optional dependencies
-try:
-    import pathvalidate
-except ModuleNotFoundError:
-    pass
-
-
-class SimpleTextBrowser:
-    """(In preview) An extremely simple text-based web browser comparable to Lynx. Suitable for Agentic use."""
-
-    def __init__(
-        self,
-        start_page: Optional[str] = None,
-        viewport_size: Optional[int] = 1024 * 8,
-        downloads_folder: Optional[Union[str, 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,
-    ):
-        self.start_page: str = start_page if start_page else "about:blank"
-        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.viewport_current_page = 0
-        self.viewport_pages: List[Tuple[int, int]] = list()
-        self.set_address(self.start_page)
-        self.bing_base_url = bing_base_url
-        self.bing_api_key = bing_api_key
-        self.request_kwargs = request_kwargs
-
-        self._page_content = ""
-
-    @property
-    def address(self) -> str:
-        """Return the address of the current page."""
-        return self.history[-1]
-
-    def set_address(self, uri_or_path: str) -> None:
-        self.history.append(uri_or_path)
-
-        # Handle special URIs
-        if uri_or_path == "about:blank":
-            self._set_page_content("")
-        elif uri_or_path.startswith("bing:"):
-            self._bing_search(uri_or_path[len("bing:") :].strip())
-        else:
-            if not uri_or_path.startswith("http:") and not uri_or_path.startswith("https:"):
-                uri_or_path = urljoin(self.address, uri_or_path)
-                self.history[-1] = uri_or_path  # Update the address with the fully-qualified path
-            self._fetch_page(uri_or_path)
-
-        self.viewport_current_page = 0
-
-    @property
-    def viewport(self) -> str:
-        """Return the content of the current viewport."""
-        bounds = self.viewport_pages[self.viewport_current_page]
-        return self.page_content[bounds[0] : bounds[1]]
-
-    @property
-    def page_content(self) -> str:
-        """Return the full contents of the current page."""
-        return self._page_content
-
-    def _set_page_content(self, content: str) -> None:
-        """Sets the text content of the current page."""
-        self._page_content = content
-        self._split_pages()
-        if self.viewport_current_page >= len(self.viewport_pages):
-            self.viewport_current_page = len(self.viewport_pages) - 1
-
-    def page_down(self) -> None:
-        self.viewport_current_page = min(self.viewport_current_page + 1, len(self.viewport_pages) - 1)
-
-    def page_up(self) -> None:
-        self.viewport_current_page = max(self.viewport_current_page - 1, 0)
-
-    def visit_page(self, path_or_uri: str) -> str:
-        """Update the address, visit the page, and return the content of the viewport."""
-        self.set_address(path_or_uri)
-        return self.viewport
-
-    def _split_pages(self) -> None:
-        # Split only regular pages
-        if not self.address.startswith("http:") and not self.address.startswith("https:"):
-            self.viewport_pages = [(0, len(self._page_content))]
-            return
-
-        # Handle empty pages
-        if len(self._page_content) == 0:
-            self.viewport_pages = [(0, 0)]
-            return
-
-        # Break the viewport into pages
-        self.viewport_pages = []
-        start_idx = 0
-        while start_idx < len(self._page_content):
-            end_idx = min(start_idx + self.viewport_size, len(self._page_content))  # type: ignore[operator]
-            # Adjust to end on a space
-            while end_idx < len(self._page_content) and self._page_content[end_idx - 1] not in [" ", "\t", "\r", "\n"]:
-                end_idx += 1
-            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]]]]]]:
-        # Make sure the key was set
-        if self.bing_api_key is None:
-            raise ValueError("Missing Bing API key.")
-
-        # Prepare the request parameters
-        request_kwargs = self.request_kwargs.copy() if self.request_kwargs is not None else {}
-
-        if "headers" not in request_kwargs:
-            request_kwargs["headers"] = {}
-        request_kwargs["headers"]["Ocp-Apim-Subscription-Key"] = self.bing_api_key
-
-        if "params" not in request_kwargs:
-            request_kwargs["params"] = {}
-        request_kwargs["params"]["q"] = query
-        request_kwargs["params"]["textDecorations"] = False
-        request_kwargs["params"]["textFormat"] = "raw"
-
-        request_kwargs["stream"] = False
-
-        # Make the request
-        response = requests.get(self.bing_base_url, **request_kwargs)
-        response.raise_for_status()
-        results = response.json()
-
-        return results  # type: ignore[no-any-return]
-
-    def _bing_search(self, query: str) -> None:
-        results = self._bing_api_call(query)
-
-        web_snippets: List[str] = list()
-        idx = 0
-        for page in results["webPages"]["value"]:
-            idx += 1
-            web_snippets.append(f"{idx}. [{page['name']}]({page['url']})\n{page['snippet']}")
-            if "deepLinks" in page:
-                for dl in page["deepLinks"]:
-                    idx += 1
-                    web_snippets.append(
-                        f"{idx}. [{dl['name']}]({dl['url']})\n{dl['snippet'] if 'snippet' in dl else ''}"  # type: ignore[index]
-                    )
-
-        news_snippets = list()
-        if "news" in results:
-            for page in results["news"]["value"]:
-                idx += 1
-                news_snippets.append(f"{idx}. [{page['name']}]({page['url']})\n{page['description']}")
-
-        self.page_title = f"{query} - Search"
-
-        content = (
-            f"A Bing search for '{query}' found {len(web_snippets) + len(news_snippets)} results:\n\n## Web Results\n"
-            + "\n\n".join(web_snippets)
-        )
-        if len(news_snippets) > 0:
-            content += "\n\n## News Results:\n" + "\n\n".join(news_snippets)
-        self._set_page_content(content)
-
-    def _fetch_page(self, url: str) -> None:
-        try:
-            # Prepare the request parameters
-            request_kwargs = self.request_kwargs.copy() if self.request_kwargs is not None else {}
-            request_kwargs["stream"] = True
-
-            # Send a HTTP request to the URL
-            response = requests.get(url, **request_kwargs)
-            response.raise_for_status()
-
-            # If the HTTP request returns a status code 200, proceed
-            if response.status_code == 200:
-                content_type = response.headers.get("content-type", "")
-                for ct in ["text/html", "text/plain", "application/pdf"]:
-                    if ct in content_type.lower():
-                        content_type = ct
-                        break
-
-                if content_type == "text/html":
-                    # Get the content of the response
-                    html = ""
-                    for chunk in response.iter_content(chunk_size=512, decode_unicode=True):
-                        html += chunk
-
-                    soup = BeautifulSoup(html, "html.parser")
-
-                    # Remove javascript and style blocks
-                    for script in soup(["script", "style"]):
-                        script.extract()
-
-                    # Convert to markdown -- Wikipedia gets special attention to get a clean version of the page
-                    if url.startswith("https://en.wikipedia.org/"):
-                        body_elm = soup.find("div", {"id": "mw-content-text"})
-                        title_elm = soup.find("span", {"class": "mw-page-title-main"})
-
-                        if body_elm:
-                            # What's the title
-                            main_title = soup.title.string
-                            if title_elm and len(title_elm) > 0:
-                                main_title = title_elm.string
-                            webpage_text = (
-                                "# " + main_title + "\n\n" + markdownify.MarkdownConverter().convert_soup(body_elm)
-                            )
-                        else:
-                            webpage_text = markdownify.MarkdownConverter().convert_soup(soup)
-                    else:
-                        webpage_text = markdownify.MarkdownConverter().convert_soup(soup)
-
-                    # Convert newlines
-                    webpage_text = re.sub(r"\r\n", "\n", webpage_text)
-
-                    # Remove excessive blank lines
-                    self.page_title = soup.title.string
-                    self._set_page_content(re.sub(r"\n{2,}", "\n\n", webpage_text).strip())
-                elif content_type == "text/plain":
-                    # Get the content of the response
-                    plain_text = ""
-                    for chunk in response.iter_content(chunk_size=512, decode_unicode=True):
-                        plain_text += chunk
-
-                    self.page_title = None
-                    self._set_page_content(plain_text)
-                elif IS_PDF_CAPABLE and content_type == "application/pdf":
-                    pdf_data = io.BytesIO(response.raw.read())
-                    self.page_title = None
-                    self._set_page_content(pdfminer.high_level.extract_text(pdf_data))
-                elif self.downloads_folder is not None:
-                    # Try producing a safe filename
-                    fname = None
-                    try:
-                        fname = pathvalidate.sanitize_filename(os.path.basename(urlparse(url).path)).strip()
-                    except NameError:
-                        pass
-
-                    # No suitable name, so make one
-                    if fname is None:
-                        extension = mimetypes.guess_extension(content_type)
-                        if extension is None:
-                            extension = ".download"
-                        fname = str(uuid.uuid4()) + extension
-
-                    # Open a file for writing
-                    download_path = os.path.abspath(os.path.join(self.downloads_folder, fname))
-                    with open(download_path, "wb") as fh:
-                        for chunk in response.iter_content(chunk_size=512):
-                            fh.write(chunk)
-
-                    # Return a page describing what just happened
-                    self.page_title = "Download complete."
-                    self._set_page_content(f"Downloaded '{url}' to '{download_path}'.")
-                else:
-                    self.page_title = f"Error - Unsupported Content-Type '{content_type}'"
-                    self._set_page_content(self.page_title)
-            else:
-                self.page_title = "Error"
-                self._set_page_content("Failed to retrieve " + url)
-        except requests.exceptions.RequestException as e:
-            self.page_title = "Error"
-            self._set_page_content(str(e))

autogen/cache/__init__.py

@@ -1,10 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-from .abstract_cache_base import AbstractCache
-from .cache import Cache
-
-__all__ = ["Cache", "AbstractCache"]