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

autogen/agentchat/contrib/capabilities/vision_capability.py

@@ -1,217 +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 copy
-from typing import Callable, Dict, List, Optional, Union
-
-from autogen.agentchat.assistant_agent import ConversableAgent
-from autogen.agentchat.contrib.capabilities.agent_capability import AgentCapability
-from autogen.agentchat.contrib.img_utils import (
-    convert_base64_to_data_uri,
-    get_image_data,
-    get_pil_image,
-    gpt4v_formatter,
-    message_formatter_pil_to_b64,
-)
-from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent
-from autogen.agentchat.conversable_agent import colored
-from autogen.code_utils import content_str
-from autogen.oai.client import OpenAIWrapper
-
-DEFAULT_DESCRIPTION_PROMPT = (
-    "Write a detailed caption for this image. "
-    "Pay special attention to any details that might be useful or relevant "
-    "to the ongoing conversation."
-)
-
-
-class VisionCapability(AgentCapability):
-    """We can add vision capability to regular ConversableAgent, even if the agent does not have the multimodal capability,
-    such as GPT-3.5-turbo agent, Llama, Orca, or Mistral agents. This vision capability will invoke a LMM client to describe
-    the image (captioning) before sending the information to the agent's actual client.
-
-        The vision capability will hook to the ConversableAgent's `process_last_received_message`.
-
-        Some technical details:
-        When the agent (who has the vision capability) received an message, it will:
-        1. _process_received_message:
-            a. _append_oai_message
-        2. generate_reply: if the agent is a MultimodalAgent, it will also use the image tag.
-            a. hook process_last_received_message (NOTE: this is where the vision capability will be hooked to.)
-            b. hook process_all_messages_before_reply
-        3. send:
-            a. hook process_message_before_send
-            b. _append_oai_message
-    """
-
-    def __init__(
-        self,
-        lmm_config: Dict,
-        description_prompt: Optional[str] = DEFAULT_DESCRIPTION_PROMPT,
-        custom_caption_func: Callable = None,
-    ) -> None:
-        """
-        Initializes a new instance, setting up the configuration for interacting with
-        a Language Multimodal (LMM) client and specifying optional parameters for image
-        description and captioning.
-
-        Args:
-            lmm_config (Dict): Configuration for the LMM client, which is used to call
-                the LMM service for describing the image. This must be a dictionary containing
-                the necessary configuration parameters. If `lmm_config` is False or an empty dictionary,
-                it is considered invalid, and initialization will assert.
-            description_prompt (Optional[str], optional): The prompt to use for generating
-                descriptions of the image. This parameter allows customization of the
-                prompt passed to the LMM service. Defaults to `DEFAULT_DESCRIPTION_PROMPT` if not provided.
-            custom_caption_func (Callable, optional): A callable that, if provided, will be used
-                to generate captions for images. This allows for custom captioning logic outside
-                of the standard LMM service interaction.
-                The callable should take three parameters as input:
-                    1. an image URL (or local location)
-                    2. image_data (a PIL image)
-                    3. lmm_client (to call remote LMM)
-                and then return a description (as string).
-                If not provided, captioning will rely on the LMM client configured via `lmm_config`.
-                If provided, we will not run the default self._get_image_caption method.
-
-        Raises:
-            AssertionError: If neither a valid `lmm_config` nor a `custom_caption_func` is provided,
-                an AssertionError is raised to indicate that the Vision Capability requires
-                one of these to be valid for operation.
-        """
-        self._lmm_config = lmm_config
-        self._description_prompt = description_prompt
-        self._parent_agent = None
-
-        if lmm_config:
-            self._lmm_client = OpenAIWrapper(**lmm_config)
-        else:
-            self._lmm_client = None
-
-        self._custom_caption_func = custom_caption_func
-        assert (
-            self._lmm_config or custom_caption_func
-        ), "Vision Capability requires a valid lmm_config or custom_caption_func."
-
-    def add_to_agent(self, agent: ConversableAgent) -> None:
-        self._parent_agent = agent
-
-        # Append extra info to the system message.
-        agent.update_system_message(agent.system_message + "\nYou've been given the ability to interpret images.")
-
-        # Register a hook for processing the last message.
-        agent.register_hook(hookable_method="process_last_received_message", hook=self.process_last_received_message)
-
-    def process_last_received_message(self, content: Union[str, List[dict]]) -> str:
-        """
-        Processes the last received message content by normalizing and augmenting it
-        with descriptions of any included images. The function supports input content
-        as either a string or a list of dictionaries, where each dictionary represents
-        a content item (e.g., text, image). If the content contains image URLs, it
-        fetches the image data, generates a caption for each image, and inserts the
-        caption into the augmented content.
-
-        The function aims to transform the content into a format compatible with GPT-4V
-        multimodal inputs, specifically by formatting strings into PIL-compatible
-        images if needed and appending text descriptions for images. This allows for
-        a more accessible presentation of the content, especially in contexts where
-        images cannot be displayed directly.
-
-        Args:
-            content (Union[str, List[dict]]): The last received message content, which
-                can be a plain text string or a list of dictionaries representing
-                different types of content items (e.g., text, image_url).
-
-        Returns:
-            str: The augmented message content
-
-        Raises:
-            AssertionError: If an item in the content list is not a dictionary.
-
-        Examples:
-            Assuming `self._get_image_caption(img_data)` returns
-            "A beautiful sunset over the mountains" for the image.
-
-        - Input as String:
-            content = "Check out this cool photo!"
-            Output: "Check out this cool photo!"
-            (Content is a string without an image, remains unchanged.)
-
-        - Input as String, with image location:
-            content = "What's weather in this cool photo: <img http://example.com/photo.jpg>"
-            Output: "What's weather in this cool photo: <img http://example.com/photo.jpg> in case you can not see, the caption of this image is:
-            A beautiful sunset over the mountains\n"
-            (Caption added after the image)
-
-        - Input as List with Text Only:
-            content = [{"type": "text", "text": "Here's an interesting fact."}]
-            Output: "Here's an interesting fact."
-            (No images in the content, it remains unchanged.)
-
-        - Input as List with Image URL:
-            content = [
-                {"type": "text", "text": "What's weather in this cool photo:"},
-                {"type": "image_url", "image_url": {"url": "http://example.com/photo.jpg"}}
-            ]
-            Output: "What's weather in this cool photo: <img http://example.com/photo.jpg> in case you can not see, the caption of this image is:
-            A beautiful sunset over the mountains\n"
-            (Caption added after the image)
-        """
-        copy.deepcopy(content)
-        # normalize the content into the gpt-4v format for multimodal
-        # we want to keep the URL format to keep it concise.
-        if isinstance(content, str):
-            content = gpt4v_formatter(content, img_format="url")
-
-        aug_content: str = ""
-        for item in content:
-            assert isinstance(item, dict)
-            if item["type"] == "text":
-                aug_content += item["text"]
-            elif item["type"] == "image_url":
-                img_url = item["image_url"]["url"]
-                img_caption = ""
-
-                if self._custom_caption_func:
-                    img_caption = self._custom_caption_func(img_url, get_pil_image(img_url), self._lmm_client)
-                elif self._lmm_client:
-                    img_data = get_image_data(img_url)
-                    img_caption = self._get_image_caption(img_data)
-                else:
-                    img_caption = ""
-
-                aug_content += f"<img {img_url}> in case you can not see, the caption of this image is: {img_caption}\n"
-            else:
-                print(f"Warning: the input type should either be `test` or `image_url`. Skip {item['type']} here.")
-
-        return aug_content
-
-    def _get_image_caption(self, img_data: str) -> str:
-        """
-        Args:
-            img_data (str): base64 encoded image data.
-        Returns:
-            str: caption for the given image.
-        """
-        response = self._lmm_client.create(
-            context=None,
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": self._description_prompt},
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": convert_base64_to_data_uri(img_data),
-                            },
-                        },
-                    ],
-                }
-            ],
-        )
-        description = response.choices[0].message.content
-        return content_str(description)

autogen/agentchat/contrib/captainagent/tools/data_analysis/calculate_correlation.py

@@ -1,41 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-def calculate_correlation(csv_path: str, column1: str, column2: str, method: str = "pearson") -> float:
-    """
-    Calculate the correlation between two columns in a CSV file.
-
-    Args:
-    csv_path (str): The path to the CSV file.
-    column1 (str): The name of the first column.
-    column2 (str): The name of the second column.
-    method (str or callable, optional): The method used to calculate the correlation.
-        - 'pearson' (default): Pearson correlation coefficient.
-        - 'kendall': Kendall Tau correlation coefficient.
-        - 'spearman': Spearman rank correlation coefficient.
-        - callable: A custom correlation function that takes two arrays and returns a scalar.
-
-    Returns:
-    float: The correlation coefficient between the two columns.
-    """
-    import pandas as pd
-
-    # Read the CSV file into a pandas DataFrame
-    df = pd.read_csv(csv_path)
-
-    # Select the specified columns
-    selected_columns = df[[column1, column2]]
-
-    # Calculate the correlation based on the specified method
-    if method == "pearson":
-        correlation = selected_columns.corr().iloc[0, 1]
-    elif method == "kendall":
-        correlation = selected_columns.corr(method="kendall").iloc[0, 1]
-    elif method == "spearman":
-        correlation = selected_columns.corr(method="spearman").iloc[0, 1]
-    elif callable(method):
-        correlation = selected_columns.corr(method=method).iloc[0, 1]
-    else:
-        raise ValueError("Invalid correlation method. Please choose 'pearson', 'kendall', 'spearman', or a callable.")
-
-    return correlation

autogen/agentchat/contrib/captainagent/tools/data_analysis/calculate_skewness_and_kurtosis.py

@@ -1,29 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-def calculate_skewness_and_kurtosis(csv_file: str, column_name: str) -> tuple:
-    """
-    Calculate the skewness and kurtosis of a specified column in a CSV file. The kurtosis is calculated using the Fisher definition.
-    The two metrics are computed using scipy.stats functions.
-
-    Args:
-    csv_file (str): The path to the CSV file.
-    column_name (str): The name of the column to calculate skewness and kurtosis for.
-
-    Returns:
-    tuple: (skewness, kurtosis)
-    """
-    import pandas as pd
-    from scipy.stats import kurtosis, skew
-
-    # Read the CSV file into a pandas DataFrame
-    df = pd.read_csv(csv_file)
-
-    # Extract the specified column
-    column = df[column_name]
-
-    # Calculate the skewness and kurtosis
-    skewness = skew(column)
-    kurt = kurtosis(column)
-
-    return skewness, kurt

autogen/agentchat/contrib/captainagent/tools/data_analysis/detect_outlier_iqr.py

@@ -1,29 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-def detect_outlier_iqr(csv_file: str, column_name: str):
-    """
-    Detect outliers in a specified column of a CSV file using the IQR method.
-
-    Args:
-    csv_file (str): The path to the CSV file.
-    column_name (str): The name of the column to detect outliers in.
-
-    Returns:
-    list: A list of row indices that correspond to the outliers.
-    """
-    import pandas as pd
-
-    # Read the CSV file into a pandas DataFrame
-    df = pd.read_csv(csv_file)
-
-    # Calculate the quartiles and IQR for the specified column
-    q1 = df[column_name].quantile(0.25)
-    q3 = df[column_name].quantile(0.75)
-    iqr = q3 - q1
-
-    # Find the outliers based on the defined criteria
-    outliers = df[(df[column_name] < q1 - 1.5 * iqr) | (df[column_name] > q3 + 1.5 * iqr)]
-
-    # Return the row indices of the outliers
-    return outliers.index.tolist()

autogen/agentchat/contrib/captainagent/tools/data_analysis/detect_outlier_zscore.py

@@ -1,29 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-def detect_outlier_zscore(csv_file, column_name, threshold=3):
-    """
-    Detect outliers in a CSV file based on a specified column. The outliers are determined by calculating the z-score of the data points in the column.
-
-    Args:
-    csv_file (str): The path to the CSV file.
-    column_name (str): The name of the column to calculate z-scores for.
-    threshold (float, optional): The threshold value for determining outliers. By default set to 3.
-
-    Returns:
-    list: A list of row indices where the z-score is above the threshold.
-    """
-    import numpy as np
-    import pandas as pd
-
-    # Read the CSV file into a pandas DataFrame
-    df = pd.read_csv(csv_file)
-
-    # Calculate the z-score for the specified column
-    z_scores = np.abs((df[column_name] - df[column_name].mean()) / df[column_name].std())
-
-    # Find the row indices where the z-score is above the threshold
-    outlier_indices = np.where(z_scores > threshold)[0]
-
-    # Return the row indices of the outliers
-    return outlier_indices

autogen/agentchat/contrib/captainagent/tools/data_analysis/explore_csv.py

@@ -1,22 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-def explore_csv(file_path, num_lines=5):
-    """
-    Reads a CSV file and prints the column names, shape, data types, and the first few lines of data.
-
-    Args:
-        file_path (str): The path to the CSV file.
-        num_lines (int, optional): The number of lines to print. Defaults to 5.
-    """
-    import pandas as pd
-
-    df = pd.read_csv(file_path)
-    header = df.columns
-    print("Columns:")
-    print(", ".join(header))
-    print("Shape:", df.shape)
-    print("Data Types:")
-    print(df.dtypes)
-    print("First", num_lines, "lines:")
-    print(df.head(num_lines))

autogen/agentchat/contrib/captainagent/tools/data_analysis/shapiro_wilk_test.py

@@ -1,31 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-from autogen.coding.func_with_reqs import with_requirements
-
-
-@with_requirements(["pandas", "scipy"])
-def shapiro_wilk_test(csv_file, column_name):
-    """
-    Perform the Shapiro-Wilk test on a specified column of a CSV file.
-
-    Args:
-    csv_file (str): The path to the CSV file.
-    column_name (str): The name of the column to perform the test on.
-
-    Returns:
-    float: The p-value resulting from the Shapiro-Wilk test.
-    """
-    import pandas as pd
-    from scipy.stats import shapiro
-
-    # Read the CSV file into a pandas DataFrame
-    df = pd.read_csv(csv_file)
-
-    # Extract the specified column as a numpy array
-    column_data = df[column_name].values
-
-    # Perform the Shapiro-Wilk test
-    _, p_value = shapiro(column_data)
-
-    return p_value

autogen/agentchat/contrib/captainagent/tools/information_retrieval/arxiv_download.py

@@ -1,26 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-import arxiv
-
-from autogen.coding.func_with_reqs import with_requirements
-
-
-@with_requirements(["arxiv"], ["arxiv"])
-def arxiv_download(id_list: list, download_dir="./"):
-    """
-    Downloads PDF files from ArXiv based on a list of arxiv paper IDs.
-
-    Args:
-        id_list (list): A list of paper IDs to download. e.g. [2302.00006v1]
-        download_dir (str, optional): The directory to save the downloaded PDF files. Defaults to './'.
-
-    Returns:
-        list: A list of paths to the downloaded PDF files.
-    """
-    paths = []
-    for paper in arxiv.Client().results(arxiv.Search(id_list=id_list)):
-        path = paper.download_pdf(download_dir, filename=paper.get_short_id() + ".pdf")
-        paths.append(path)
-        print("Paper id:", paper.get_short_id(), "Downloaded to:", path)
-    return paths

autogen/agentchat/contrib/captainagent/tools/information_retrieval/arxiv_search.py

@@ -1,55 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-import arxiv
-
-from autogen.coding.func_with_reqs import with_requirements
-
-
-@with_requirements(["arxiv"], ["arxiv"])
-def arxiv_search(query, max_results=10, sortby="relevance"):
-    """
-    Search for articles on arXiv based on the given query.
-
-    Args:
-        query (str): The search query.
-        max_results (int, optional): The maximum number of results to retrieve. Defaults to 10.
-        sortby (str, optional): The sorting criterion for the search results. Can be 'relevance' or 'submittedDate'. Defaults to 'relevance'.
-
-    Returns:
-        list: A list of dictionaries containing information about the search results. Each dictionary contains the following keys:
-            - 'title': The title of the article.
-            - 'authors': The authors of the article.
-            - 'summary': The summary of the article.
-            - 'entry_id': The entry ID of the article.
-            - 'doi': The DOI of the article (If applicable).
-            - 'published': The publication date of the article in the format 'Y-M'.
-    """
-
-    def get_author(r):
-        return ", ".join(a.name for a in r.authors)
-
-    criterion = {"relevance": arxiv.SortCriterion.Relevance, "submittedDate": arxiv.SortCriterion.SubmittedDate}[sortby]
-
-    client = arxiv.Client()
-    search = arxiv.Search(query=query, max_results=max_results, sort_by=criterion)
-    res = []
-    results = client.results(search)
-    for r in results:
-        print("Entry id:", r.entry_id)
-        print("Title:", r.title)
-        print("Authors:", get_author(r))
-        print("DOI:", r.doi)
-        print("Published:", r.published.strftime("%Y-%m"))
-        # print("Summary:", r.summary)
-        res.append(
-            {
-                "title": r.title,
-                "authors": get_author(r),
-                "summary": r.summary,
-                "entry_id": r.entry_id,
-                "doi": r.doi,
-                "published": r.published.strftime("%Y-%m"),
-            }
-        )
-    return res

autogen/agentchat/contrib/captainagent/tools/information_retrieval/extract_pdf_image.py

@@ -1,54 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-import os
-
-from autogen.coding.func_with_reqs import with_requirements
-
-
-@with_requirements(["PyMuPDF"], ["os"])
-def extract_pdf_image(pdf_path: str, output_dir: str, page_number=None):
-    """
-    Extracts images from a PDF file and saves them to the specified output directory.
-
-    Args:
-        pdf_path (str): The path to the PDF file.
-        output_dir (str): The directory to save the extracted images.
-        page_number (int, optional): The page number to extract images from. If not provided, extract images from all pages.
-    """
-    import fitz  # PyMuPDF library
-
-    # Open the PDF file
-    doc = fitz.open(pdf_path)
-
-    # Create the output directory if it doesn't exist
-    os.makedirs(output_dir, exist_ok=True)
-
-    # Extract images from the PDF file
-    images = []
-    if page_number is not None:
-        page = doc[page_number - 1]  # Adjust page number to 0-based index
-        for img in page.get_images():
-            xref = img[0]
-            base_image = doc.extract_image(xref)
-            image_bytes = base_image["image"]
-            images.append(image_bytes)
-    else:
-        for page in doc:
-            for img in page.get_images():
-                xref = img[0]
-                base_image = doc.extract_image(xref)
-                image_bytes = base_image["image"]
-                images.append(image_bytes)
-
-    # Save the extracted images
-    for i, image_bytes in enumerate(images):
-        image_path = os.path.join(output_dir, f"image_{i}.png")
-        with open(image_path, "wb") as f:
-            f.write(image_bytes)
-
-    # Print the total number of images saved
-    print(f"Saved a total of {len(images)} images")
-
-    # Close the PDF file
-    doc.close()

autogen/agentchat/contrib/captainagent/tools/information_retrieval/extract_pdf_text.py

@@ -1,39 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-from autogen.coding.func_with_reqs import with_requirements
-
-
-@with_requirements(["PyMuPDF"])
-def extract_pdf_text(pdf_path, page_number=None):
-    """
-    Extracts text from a specified page or the entire PDF file.
-
-    Args:
-        pdf_path (str): The path to the PDF file.
-        page_number (int, optional): The page number to extract (starting from 0). If not provided,
-            the function will extract text from the entire PDF file.
-
-    Returns:
-        str: The extracted text.
-    """
-    import fitz
-
-    # Open the PDF file
-    doc = fitz.open(pdf_path)
-
-    # Extract text from the entire PDF file or a specific page
-    text = ""
-    if page_number is None:
-        # Extract content from the entire PDF file
-        for page in doc:
-            text += page.get_text()
-    else:
-        # Extract content from a specific page
-        page = doc[page_number]
-        text = page.get_text()
-
-    # Close the PDF file
-    doc.close()
-
-    return text

autogen/agentchat/contrib/captainagent/tools/information_retrieval/get_wikipedia_text.py

@@ -1,22 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-def get_wikipedia_text(title):
-    """
-    Retrieves the text content of a Wikipedia page. It does not support tables and other complex formatting.
-
-    Args:
-        title (str): The title of the Wikipedia page.
-
-    Returns:
-        str or None: The text content of the Wikipedia page if it exists, None otherwise.
-    """
-    import wikipediaapi
-
-    wiki_wiki = wikipediaapi.Wikipedia("Mozilla/5.0 (merlin@example.com)", "en")
-    page = wiki_wiki.page(title)
-
-    if page.exists():
-        return page.text
-    else:
-        return None

autogen/agentchat/contrib/captainagent/tools/information_retrieval/get_youtube_caption.py

@@ -1,35 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-# alternative api: https://rapidapi.com/omarmhaimdat/api/youtube-v2
-
-
-def get_youtube_caption(videoId):
-    """
-    Retrieves the captions for a YouTube video.
-
-    Args:
-        videoId (str): The ID of the YouTube video.
-
-    Returns:
-        str: The captions of the YouTube video in text format.
-
-    Raises:
-        KeyError: If the RAPID_API_KEY environment variable is not set.
-    """
-    import os
-
-    import requests
-
-    RAPID_API_KEY = os.environ["RAPID_API_KEY"]
-    video_url = f"https://www.youtube.com/watch?v={videoId}"
-    url = "https://youtube-transcript3.p.rapidapi.com/api/transcript-with-url"
-
-    querystring = {"url": video_url, "lang": "en", "flat_text": "true"}
-
-    headers = {"X-RapidAPI-Key": RAPID_API_KEY, "X-RapidAPI-Host": "youtube-transcript3.p.rapidapi.com"}
-
-    response = requests.get(url, headers=headers, params=querystring)
-    response = response.json()
-    print(response)
-    return response["transcript"]