lionagi 0.5.5__py3-none-any.whl → 0.6.0__py3-none-any.whl

lionagi/integrations/openai_/api_endpoints/uploads/uploads_models.py

@@ -1,52 +0,0 @@
-from typing import Optional
-
-from pydantic import Field
-
-from ..data_models import OpenAIEndpointResponseBody
-from ..files.file_models import OpenAIFileResponseBody, Purpose
-
-
-class OpenAIUploadResponseBody(OpenAIEndpointResponseBody):
-    id: str = Field(description="The Upload unique identifier.")
-
-    created_at: int = Field(
-        description="The Unix timestamp (in seconds) for when the Upload was created.",
-    )
-
-    filename: str = Field(description="The name of the file to be uploaded.")
-
-    bytes: int = Field(
-        description="The intended number of bytes to be uploaded."
-    )
-
-    purpose: Purpose = Field(description="The intended purpose of the file.")
-
-    status: str = Field(description="The status of the Upload.")
-
-    expires_at: int = Field(
-        description="The Unix timestamp (in seconds) for when the Upload expires."
-    )
-
-    object: str = Field(
-        description="The object type, which is always 'upload'."
-    )
-
-    file: OpenAIFileResponseBody | None = Field(
-        None, description="The File object created after completion."
-    )
-
-
-class OpenAIUploadPartResponseBody(OpenAIUploadResponseBody):
-    id: str = Field(description="The upload Part unique identifier.")
-
-    created_at: int = Field(
-        description="The Unix timestamp (in seconds) for when the Part was created.",
-    )
-
-    upload_id: str = Field(
-        description="The ID of the Upload object that this Part was added to."
-    )
-
-    object: str = Field(
-        description="The object type, which is always 'upload.part'."
-    )

lionagi/integrations/openai_/image_token_calculator/image_token_calculator.py

@@ -1,98 +0,0 @@
-import base64
-import math
-import os
-from io import BytesIO
-from typing import Literal
-
-from pydantic import BaseModel, Field, field_validator
-
-image_token_config_file_name = os.path.join(
-    os.path.dirname(__file__), "openai_image_token_data.yaml"
-)
-
-
-class _ModuelImportClass:
-
-    from lionagi.libs.package.imports import check_import
-
-    yaml = check_import("yaml", pip_name="pyyaml")
-    Image = check_import("PIL.Image", pip_name="Pillow")
-    aiohttp = check_import("aiohttp")
-
-
-class OpenAIImageTokenCalculator(BaseModel):
-    model: str = Field(description="ID of the model to use.")
-
-    @field_validator("model")
-    @classmethod
-    def validate_model_image_function(cls, value: str):
-        with open(image_token_config_file_name) as file:
-            token_config = _ModuelImportClass.yaml.safe_load(file)
-
-        token_config = token_config.get(value, None)
-
-        if token_config is None:
-            raise ValueError("The model does not have vision capabilities.")
-        return value
-
-    @staticmethod
-    async def get_image_size(url: str):
-        if url.startswith("data:image/jpeg;base64,"):
-            # base64 encoded format
-            image_base64 = url.split("data:image/jpeg;base64,")[1]
-            image_base64.strip("{}")
-            image_data = base64.b64decode(image_base64)
-            image = _ModuelImportClass.Image.open(BytesIO(image_data))
-        else:
-            # image url
-            async with _ModuelImportClass.aiohttp.ClientSession() as client:
-                async with client.get(url=url) as response:
-                    response.raise_for_status()
-
-                    content = await response.read()
-
-                    image = _ModuelImportClass.Image.open(BytesIO(content))
-
-        return image.size
-
-    async def calculate(
-        self, url: str, detail: Literal["low", "high", "auto"] = "auto"
-    ):
-        if detail not in ["low", "high", "auto"]:
-            raise ValueError(
-                "Invalid detail option. Valid options are: low, high, auto"
-            )
-
-        with open(image_token_config_file_name) as file:
-            token_config = _ModuelImportClass.yaml.safe_load(file)
-
-        token_config = token_config.get(self.model, None)
-
-        if token_config is None:
-            raise ValueError("The model does not have vision capabilities.")
-
-        width, height = await self.get_image_size(url)
-
-        if detail == "low":
-            return token_config["base"]
-        if detail == "auto":
-            # TODO: check "auto" option condition
-            if width <= 512 and height <= 512:
-                return token_config["base"]
-
-        # Scale to fit within a 2048 x 2048 square
-        if max(width, height) > 2048:
-            scale_factor = 2048 / max(width, height)
-            width = int(width * scale_factor)
-            height = int(height * scale_factor)
-
-        # Scale such that the shortest side is 768px
-        if min(width, height) > 768:
-            scale_factor = 768 / min(width, height)
-            width = int(width * scale_factor)
-            height = int(height * scale_factor)
-
-        # Calculate the number of 512px squares
-        num_squares = math.ceil(width / 512) * math.ceil(height / 512)
-
-        return num_squares * token_config["tile"] + token_config["base"]

lionagi/integrations/openai_/image_token_calculator/openai_image_token_data.yaml

@@ -1,15 +0,0 @@
-gpt-4o:
-  base: 85
-  tile: 170
-gpt-4o-2024-05-13:
-  base: 85
-  tile: 170
-gpt-4o-2024-08-06:
-  base: 85
-  tile: 170
-gpt-4o-mini:
-  base: 2833
-  tile: 5667
-gpt-4o-mini-2024-07-18:
-  base: 2833
-  tile: 5667

lionagi/integrations/openai_/openai_max_output_token_data.yaml

@@ -1,12 +0,0 @@
-gpt-4o: 4096
-gpt-4o-2024-05-13: 4096
-gpt-4o-2024-08-06: 16384
-gpt-4o-mini: 16384
-gpt-4o-mini-2024-07-18: 16384
-gpt-4-turbo: 4096
-gpt-4-turbo-2024-04-09: 4096
-gpt-4-turbo-preview: 4096
-gpt-4-0125-preview: 4096
-gpt-4-1106-preview: 4096
-gpt-4: 8192
-gpt-4-0613: 8192

lionagi/integrations/openai_/openai_price_data.yaml

@@ -1,26 +0,0 @@
-model:
-  gpt-4o:
-    input_tokens: 0.000005
-    output_tokens: 0.000015
-    input_tokens_with_batch: 0.0000025
-    output_tokens_with_batch: 0.0000075
-  gpt-4o-2024-08-06:
-    input_tokens: 0.0000025
-    output_tokens: 0.00001
-    input_tokens_with_batch: 0.00000125
-    output_tokens_with_batch: 0.000005
-  gpt-4o-2024-05-13:
-    input_tokens: 0.000005
-    output_tokens: 0.000015
-    input_tokens_with_batch: 0.0000025
-    output_tokens_with_batch: 0.0000075
-  gpt-4o-mini:
-    input_tokens: 0.00000015
-    output_tokens: 0.0000006
-    input_tokens_with_batch: 0.000000075
-    output_tokens_with_batch: 0.0000003
-  gpt-4o-mini-2024-07-18:
-    input_tokens: 0.00000015
-    output_tokens: 0.0000006
-    input_tokens_with_batch: 0.000000075
-    output_tokens_with_batch: 0.0000003

lionagi/integrations/openai_/version.py

@@ -1 +0,0 @@
-__version__ = "1.0.3"

lionagi/integrations/pandas_/__init__.py

@@ -1,24 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-from .extend_df import extend_dataframe
-from .read import read_csv, read_json
-from .remove_rows import remove_rows
-from .replace_keywords import replace_keywords
-from .save import to_csv, to_excel
-from .search_keywords import search_dataframe_keywords
-from .to_df import to_df
-from .update_cells import update_cells
-
-__all__ = [
-    "to_df",
-    "replace_keywords",
-    "search_dataframe_keywords",
-    "read_csv",
-    "read_json",
-    "to_csv",
-    "to_excel",
-    "extend_dataframe",
-    "remove_rows",
-    "update_cells",
-]

lionagi/integrations/pandas_/extend_df.py

@@ -1,61 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-from typing import Any, Literal
-
-import pandas as pd
-
-from lionagi.integrations.pandas_.to_df import to_df
-
-
-def extend_dataframe(
-    dataframes: list[pd.DataFrame],
-    unique_col: str = "node_id",
-    keep: Literal["first", "last", False] = "first",
-    ignore_index: bool = False,
-    sort: bool = False,
-    **kwargs: Any,
-) -> pd.DataFrame:
-    """
-    Merges multiple DataFrames while ensuring no duplicate entries based on a specified unique column.
-
-    Args:
-        dataframes: List of DataFrames to merge, with the first being the primary DataFrame.
-        unique_col: The column name to check for duplicate entries. Defaults to 'node_id'.
-        keep: Determines which duplicates to keep. 'first' keeps the first occurrence,
-              'last' keeps the last occurrence, and False drops all duplicates.
-        ignore_index: If True, the resulting axis will be labeled 0, 1, …, n - 1.
-        sort: If True, sort the join keys lexicographically in the result DataFrame.
-        **kwargs: Additional keyword arguments for `drop_duplicates`.
-
-    Returns:
-        A DataFrame combined from all input DataFrames with duplicates removed based on the unique column.
-
-    Raises:
-        ValueError: If all DataFrames are empty or if there's an error in extending.
-
-    Example:
-        >>> df1 = pd.DataFrame({'node_id': [1, 2], 'value': ['a', 'b']})
-        >>> df2 = pd.DataFrame({'node_id': [2, 3], 'value': ['c', 'd']})
-        >>> extend_dataframe([df1, df2], keep='last', ignore_index=True)
-           node_id value
-        0       1     a
-        1       2     c
-        2       3     d
-    """
-    try:
-        if all(df.empty for df in dataframes):
-            raise ValueError("All input DataFrames are empty.")
-
-        combined = pd.concat(dataframes, ignore_index=ignore_index, sort=sort)
-        result = combined.drop_duplicates(
-            subset=[unique_col], keep=keep, **kwargs
-        )
-
-        if result.empty:
-            raise ValueError("No data left after removing duplicates.")
-
-        return to_df(result)
-
-    except Exception as e:
-        raise ValueError(f"Error in extending DataFrames: {e}") from e

lionagi/integrations/pandas_/read.py

@@ -1,103 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-from typing import Any, Literal
-
-import pandas as pd
-
-from .to_df import to_df
-
-
-def read_csv(
-    filepath: str,
-    chunk_size: int | None = None,
-    low_memory: bool = False,
-    return_as: Literal["dataframe", "json", "jsonl", "dict"] = "dataframe",
-    **kwargs: Any,
-) -> pd.DataFrame | str | list | dict:
-    """
-    Reads a CSV file into a DataFrame with optional chunking for large files.
-
-    Args:
-        filepath: The path to the CSV file to read.
-        chunk_size: Number of rows to read at a time. If specified, returns an iterable.
-        low_memory: Internally process the file in chunks to conserve memory (slower).
-        **kwargs: Additional keyword arguments to pass to pandas.read_csv function.
-
-    Returns:
-        A DataFrame containing the data read from the CSV file, or a TextFileReader
-        if chunk_size is specified.
-
-    Example:
-        >>> df = read_csv('large_file.csv', chunk_size=10000)
-        >>> for chunk in df:
-        ...     process_chunk(chunk)
-    """
-    try:
-        if chunk_size:
-            return pd.read_csv(
-                filepath, chunksize=chunk_size, low_memory=low_memory, **kwargs
-            )
-        df = pd.read_csv(filepath, low_memory=low_memory, **kwargs)
-        df = to_df(df)
-        if return_as == "dataframe":
-            return df
-        if return_as == "json":
-            return df.to_json(orient="records")
-        if return_as == "jsonl":
-            return df.to_json(orient="records", lines=True)
-        if return_as == "dict":
-            return df.to_dict(orient="records")
-
-    except Exception as e:
-        raise OSError(f"Error reading CSV file: {e}") from e
-
-
-def read_json(
-    filepath: str,
-    orient: str | None = None,
-    lines: bool = False,
-    chunk_size: int | None = None,
-    return_as: Literal["dataframe", "json", "jsonl", "dict"] = "dataframe",
-    **kwargs: Any,
-) -> pd.DataFrame | pd.io.json._json.JsonReader:
-    """
-    Reads a JSON file into a DataFrame with options for different JSON formats.
-
-    Args:
-        filepath: The path to the JSON file to read.
-        orient: Indication of expected JSON string format.
-                Allowed values are: 'split', 'records', 'index', 'columns', 'values', 'table'.
-        lines: Read the file as a json object per line.
-        chunk_size: Number of lines to read at a time. If specified, returns an iterable.
-        **kwargs: Additional keyword arguments to pass to pandas.read_json function.
-
-    Returns:
-        A DataFrame containing the data read from the JSON file, or a JsonReader
-        if chunk_size is specified.
-
-    Example:
-        >>> df = read_json('data.json', orient='records', lines=True)
-    """
-    try:
-        if chunk_size:
-            return pd.read_json(
-                filepath,
-                orient=orient,
-                lines=lines,
-                chunksize=chunk_size,
-                **kwargs,
-            )
-        df = pd.read_json(filepath, orient=orient, lines=lines, **kwargs)
-        df = to_df(df)
-        if return_as == "dataframe":
-            return df
-        if return_as == "json":
-            return df.to_json(orient="records")
-        if return_as == "jsonl":
-            return df.to_json(orient="records", lines=True)
-        if return_as == "dict":
-            return df.to_dict(orient="records")
-
-    except Exception as e:
-        raise OSError(f"Error reading JSON file: {e}") from e

lionagi/integrations/pandas_/remove_rows.py

@@ -1,61 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-import pandas as pd
-
-from .to_df import to_df
-
-
-def remove_rows(
-    df: pd.DataFrame,
-    rows: int | slice | list[int],
-    from_end: bool = False,
-    reset_index: bool = False,
-) -> pd.DataFrame:
-    """
-    Removes specified rows from a DataFrame.
-
-    Args:
-        df: The DataFrame from which to remove rows.
-        rows: The row(s) to remove. Can be an integer, slice, or list of integers.
-        from_end: If True, count rows from the end of the DataFrame.
-        reset_index: If True, reset the index after removing rows.
-
-    Returns:
-        A DataFrame with the specified rows removed.
-
-    Raises:
-        ValueError: If the specified rows are invalid.
-
-    Example:
-        >>> df = pd.DataFrame({'A': range(10)})
-        >>> remove_rows(df, [0, 2, 4], reset_index=True)
-           A
-        0  1
-        1  3
-        2  5
-        3  6
-        4  7
-        5  8
-        6  9
-    """
-    if df.empty:
-        return df.copy()
-
-    if isinstance(rows, int):
-        rows = [rows]
-    elif isinstance(rows, slice):
-        rows = list(range(*rows.indices(len(df))))
-
-    if from_end:
-        rows = [len(df) - 1 - r for r in rows]
-
-    try:
-        result = df.drop(df.index[rows])
-    except IndexError as e:
-        raise ValueError(f"Invalid row selection: {e}") from e
-
-    if reset_index:
-        result = result.reset_index(drop=True)
-
-    return to_df(result)

lionagi/integrations/pandas_/replace_keywords.py

@@ -1,65 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-import pandas as pd
-
-from .to_df import to_df
-
-
-def replace_keywords(
-    df: pd.DataFrame,
-    keyword: str | dict[str, str],
-    replacement: str | None = None,
-    *,
-    column: str | list[str] = "content",
-    case_sensitive: bool = False,
-    regex: bool = False,
-    inplace: bool = False,
-) -> pd.DataFrame | None:
-    """
-    Replaces occurrences of specified keyword(s) with replacement string(s) in DataFrame column(s).
-
-    Args:
-        df: The DataFrame to modify.
-        keyword: The keyword to be replaced. Can be a string or a dictionary of {old: new} pairs.
-        replacement: The string to replace the keyword with. Ignored if keyword is a dict.
-        column: The column(s) in which to perform the replacement. Can be a string or list of strings.
-        case_sensitive: If True, performs a case-sensitive replacement.
-        regex: If True, treat keyword(s) as regular expressions.
-        inplace: If True, modifies the DataFrame in place and returns None.
-
-    Returns:
-        Modified DataFrame if inplace is False, None otherwise.
-
-    Example:
-        >>> df = pd.DataFrame({'content': ['apple pie', 'banana split', 'cherry pie']})
-        >>> replace_keyword(df, {'pie': 'tart', 'split': 'smoothie'}, column='content')
-           content
-        0  apple tart
-        1  banana smoothie
-        2  cherry tart
-    """
-    df_ = df if inplace else df.copy()
-
-    if isinstance(column, str):
-        column = [column]
-
-    if isinstance(keyword, dict):
-        for col in column:
-            df_[col] = df_[col].replace(
-                to_replace=keyword,
-                regex=regex,
-                case=case_sensitive,
-            )
-    else:
-        for col in column:
-            df_[col] = df_[col].replace(
-                to_replace=keyword,
-                value=replacement,
-                regex=regex,
-                case=case_sensitive,
-            )
-
-    if inplace:
-        return None
-    return to_df(df_)

lionagi/integrations/pandas_/save.py

@@ -1,131 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-from pathlib import Path
-from typing import Any
-
-from lionagi.integrations.pandas_.to_df import to_df
-from lionagi.libs.file.types import create_path
-
-
-def to_csv(
-    input_: Any,
-    /,
-    *,
-    directory: str | Path,
-    filename: str,
-    timestamp: bool = False,
-    random_hash_digits: int = 0,
-    drop_how: str = "all",
-    drop_kwargs: dict[str, Any] | None = None,
-    reset_index: bool = True,
-    concat_kwargs: dict[str, Any] | None = None,
-    df_kwargs: dict[str, Any] | None = None,
-    path_kwargs: dict[str, Any] | None = None,
-    verbose: bool = False,
-) -> None:
-    """
-    Convert input to a DataFrame and save it as a CSV file.
-
-    Args:
-        input_: The input data to convert to a DataFrame.
-        directory: The directory to save the CSV file.
-        filename: The name of the CSV file (without extension).
-        timestamp: If True, add a timestamp to the filename.
-        random_hash_digits: Number of random hash digits to add to the filename.
-        drop_how: How to drop NA values in the DataFrame.
-        drop_kwargs: Additional keyword arguments for dropna().
-        reset_index: If True, reset the index of the DataFrame.
-        concat_kwargs: Keyword arguments for pandas.concat().
-        df_kwargs: Additional keyword arguments for to_df().
-        path_kwargs: Additional keyword arguments for create_path().
-        verbose: If True, print the file path after saving.
-
-    Returns:
-        None
-    """
-    df = to_df(
-        input_,
-        drop_how=drop_how,
-        drop_kwargs=drop_kwargs,
-        reset_index=reset_index,
-        concat_kwargs=concat_kwargs,
-        **(df_kwargs or {}),
-    )
-
-    fp = create_path(
-        directory=directory,
-        filename=filename,
-        timestamp=timestamp,
-        random_hash_digits=random_hash_digits,
-        extension="csv",
-        **(path_kwargs or {}),
-    )
-
-    df.to_csv(fp, index=False)
-
-    if verbose:
-        print(f"Data saved to {fp}")
-
-
-def to_excel(
-    input_: Any,
-    /,
-    *,
-    directory: str | Path,
-    filename: str,
-    timestamp: bool = False,
-    random_hash_digits: int = 0,
-    drop_how: str = "all",
-    drop_kwargs: dict[str, Any] | None = None,
-    reset_index: bool = True,
-    concat_kwargs: dict[str, Any] | None = None,
-    df_kwargs: dict[str, Any] | None = None,
-    path_kwargs: dict[str, Any] | None = None,
-    verbose: bool = False,
-) -> None:
-    """
-    Convert input to a DataFrame and save it as an Excel file.
-
-    Args:
-        input_: The input data to convert to a DataFrame.
-        directory: The directory to save the Excel file.
-        filename: The name of the Excel file (without extension).
-        timestamp: If True, add a timestamp to the filename.
-        random_hash_digits: Number of random hash digits to add to the filename.
-        drop_how: How to drop NA values in the DataFrame.
-        drop_kwargs: Additional keyword arguments for dropna().
-        reset_index: If True, reset the index of the DataFrame.
-        concat_kwargs: Keyword arguments for pandas.concat().
-        df_kwargs: Additional keyword arguments for to_df().
-        path_kwargs: Additional keyword arguments for create_path().
-        verbose: If True, print the file path after saving.
-
-    Returns:
-        None
-    """
-    df = to_df(
-        input_,
-        drop_how=drop_how,
-        drop_kwargs=drop_kwargs,
-        reset_index=reset_index,
-        concat_kwargs=concat_kwargs,
-        **(df_kwargs or {}),
-    )
-
-    fp = create_path(
-        directory=directory,
-        filename=filename,
-        timestamp=timestamp,
-        random_hash_digits=random_hash_digits,
-        extension="xlsx",
-        **(path_kwargs or {}),
-    )
-
-    df.to_excel(fp, index=False)
-
-    if verbose:
-        print(f"Data saved to {fp}")
-
-
-__all__ = ["to_csv", "to_excel"]