camel-ai 0.2.59__py3-none-any.whl → 0.2.82__py3-none-any.whl

camel/loaders/pandas_reader.py

@@ -1,368 +0,0 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-from functools import wraps
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
-
-if TYPE_CHECKING:
-    from pandas import DataFrame
-    from pandasai import SmartDataframe
-
-
-def check_suffix(valid_suffixs: List[str]) -> Callable:
-    r"""A decorator to check the file suffix of a given file path.
-
-    Args:
-        valid_suffix (str): The required file suffix.
-
-    Returns:
-        Callable: The decorator function.
-    """
-
-    def decorator(func: Callable):
-        @wraps(func)
-        def wrapper(
-            self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-        ) -> "DataFrame":
-            suffix = Path(file_path).suffix
-            if suffix not in valid_suffixs:
-                raise ValueError(
-                    f"Only {', '.join(valid_suffixs)} files are supported"
-                )
-            return func(self, file_path, *args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-class PandasReader:
-    def __init__(self, config: Optional[Dict[str, Any]] = None) -> None:
-        r"""Initializes the PandasReader class.
-
-        Args:
-            config (Optional[Dict[str, Any]], optional): The configuration
-                dictionary that can include LLM API settings for LLM-based
-                processing. If not provided, no LLM will be configured by
-                default. You can customize the LLM configuration by providing
-                a 'llm' key in the config dictionary. (default: :obj:`None`)
-        """
-        self.config = config or {}
-
-        self.__LOADER = {
-            ".csv": self.read_csv,
-            ".xlsx": self.read_excel,
-            ".xls": self.read_excel,
-            ".json": self.read_json,
-            ".parquet": self.read_parquet,
-            ".sql": self.read_sql,
-            ".html": self.read_html,
-            ".feather": self.read_feather,
-            ".dta": self.read_stata,
-            ".sas": self.read_sas,
-            ".pkl": self.read_pickle,
-            ".h5": self.read_hdf,
-            ".orc": self.read_orc,
-        }
-
-    def load(
-        self,
-        data: Union["DataFrame", str],
-        *args: Any,
-        **kwargs: Dict[str, Any],
-    ) -> Union["DataFrame", "SmartDataframe"]:
-        r"""Loads a file or DataFrame and returns a DataFrame or
-        SmartDataframe object.
-
-        If an LLM is configured in the config dictionary, a SmartDataframe
-        will be returned, otherwise a regular pandas DataFrame will be
-        returned.
-
-        args:
-            data (Union[DataFrame, str]): The data to load.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            Union[DataFrame, SmartDataframe]: The DataFrame or SmartDataframe
-                object.
-        """
-        from pandas import DataFrame
-
-        # Load the data into a pandas DataFrame
-        if isinstance(data, DataFrame):
-            df = data
-        else:
-            file_path = str(data)
-            path = Path(file_path)
-            if not file_path.startswith("http") and not path.exists():
-                raise FileNotFoundError(f"File {file_path} not found")
-            if path.suffix in self.__LOADER:
-                df = self.__LOADER[path.suffix](file_path, *args, **kwargs)  # type: ignore[operator]
-            else:
-                raise ValueError(f"Unsupported file format: {path.suffix}")
-
-        # If an LLM is configured, return a SmartDataframe, otherwise return a
-        # regular DataFrame
-        if "llm" in self.config:
-            from pandasai import SmartDataframe
-
-            return SmartDataframe(df, config=self.config)
-        else:
-            return df
-
-    @check_suffix([".csv"])
-    def read_csv(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a CSV file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the CSV file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_csv(file_path, *args, **kwargs)
-
-    @check_suffix([".xlsx", ".xls"])
-    def read_excel(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads an Excel file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the Excel file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_excel(file_path, *args, **kwargs)
-
-    @check_suffix([".json"])
-    def read_json(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a JSON file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the JSON file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_json(file_path, *args, **kwargs)
-
-    @check_suffix([".parquet"])
-    def read_parquet(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a Parquet file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the Parquet file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_parquet(file_path, *args, **kwargs)
-
-    def read_sql(self, *args: Any, **kwargs: Dict[str, Any]) -> "DataFrame":
-        r"""Reads a SQL file and returns a DataFrame.
-
-        Args:
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_sql(*args, **kwargs)
-
-    def read_table(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a table and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the table.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_table(file_path, *args, **kwargs)
-
-    def read_clipboard(
-        self, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a clipboard and returns a DataFrame.
-
-        Args:
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_clipboard(*args, **kwargs)
-
-    @check_suffix([".html"])
-    def read_html(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads an HTML file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the HTML file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_html(file_path, *args, **kwargs)
-
-    @check_suffix([".feather"])
-    def read_feather(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a Feather file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the Feather file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_feather(file_path, *args, **kwargs)
-
-    @check_suffix([".dta"])
-    def read_stata(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a Stata file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the Stata file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_stata(file_path, *args, **kwargs)
-
-    @check_suffix([".sas"])
-    def read_sas(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a SAS file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the SAS file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_sas(file_path, *args, **kwargs)
-
-    @check_suffix([".pkl"])
-    def read_pickle(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads a Pickle file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the Pickle file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_pickle(file_path, *args, **kwargs)
-
-    @check_suffix([".h5"])
-    def read_hdf(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads an HDF file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the HDF file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_hdf(file_path, *args, **kwargs)
-
-    @check_suffix([".orc"])
-    def read_orc(
-        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
-    ) -> "DataFrame":
-        r"""Reads an ORC file and returns a DataFrame.
-
-        Args:
-            file_path (str): The path to the ORC file.
-            *args (Any): Additional positional arguments.
-            **kwargs (Dict[str, Any]): Additional keyword arguments.
-
-        Returns:
-            DataFrame: The DataFrame object.
-        """
-        import pandas as pd
-
-        return pd.read_orc(file_path, *args, **kwargs)

camel/runtime/api.py

@@ -1,97 +0,0 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-import importlib
-import io
-import json
-import logging
-import os
-import sys
-from typing import Dict
-
-import uvicorn
-from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
-
-from camel.toolkits import BaseToolkit
-
-logger = logging.getLogger(__name__)
-
-sys.path.append(os.getcwd())
-
-modules_functions = sys.argv[1:]
-
-logger.info(f"Modules and functions: {modules_functions}")
-
-app = FastAPI()
-
-
-@app.exception_handler(Exception)
-async def general_exception_handler(request: Request, exc: Exception):
-    return JSONResponse(
-        status_code=500,
-        content={
-            "detail": "Internal Server Error",
-            "error_message": str(exc),
-        },
-    )
-
-
-for module_function in modules_functions:
-    try:
-        init_params = dict()
-        if "{" in module_function:
-            module_function, params = module_function.split("{")
-            params = "{" + params
-            init_params = json.loads(params)
-
-        module_name, function_name = module_function.rsplit(".", 1)
-
-        logger.info(f"Importing {module_name} and function {function_name}")
-
-        module = importlib.import_module(module_name)
-        function = getattr(module, function_name)
-        if isinstance(function, type) and issubclass(function, BaseToolkit):
-            function = function(**init_params).get_tools()
-
-        if not isinstance(function, list):
-            function = [function]
-
-        for func in function:
-
-            @app.post(f"/{func.get_function_name()}")
-            async def dynamic_function(data: Dict, func=func):
-                redirect_stdout = data.get('redirect_stdout', False)
-                if redirect_stdout:
-                    sys.stdout = io.StringIO()
-                response_data = func.func(*data['args'], **data['kwargs'])
-                if redirect_stdout:
-                    sys.stdout.seek(0)
-                    output = sys.stdout.read()
-                    sys.stdout = sys.__stdout__
-                    return {
-                        "output": json.dumps(
-                            response_data, ensure_ascii=False
-                        ),
-                        "stdout": output,
-                    }
-                return {
-                    "output": json.dumps(response_data, ensure_ascii=False)
-                }
-
-    except (ImportError, AttributeError) as e:
-        logger.error(f"Error importing {module_function}: {e}")
-
-
-if __name__ == "__main__":
-    uvicorn.run("__main__:app", host="0.0.0.0", port=8000, reload=True)

camel/toolkits/dalle_toolkit.py

@@ -1,171 +0,0 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-import base64
-import os
-import uuid
-from io import BytesIO
-from typing import List, Optional
-
-from openai import OpenAI
-from PIL import Image
-
-from camel.logger import get_logger
-from camel.toolkits import FunctionTool
-from camel.toolkits.base import BaseToolkit
-from camel.utils import MCPServer
-
-logger = get_logger(__name__)
-
-
-@MCPServer()
-class DalleToolkit(BaseToolkit):
-    r"""A class representing a toolkit for image generation using OpenAI's
-    DALL-E model.
-    """
-
-    def __init__(
-        self,
-        timeout: Optional[float] = None,
-    ):
-        r"""Initializes a new instance of the DalleToolkit class.
-
-        Args:
-            timeout (Optional[float]): The timeout value for API requests
-                in seconds. If None, no timeout is applied.
-                (default: :obj:`None`)
-        """
-        super().__init__(timeout=timeout)
-
-    def base64_to_image(self, base64_string: str) -> Optional[Image.Image]:
-        r"""Converts a base64 encoded string into a PIL Image object.
-
-        Args:
-            base64_string (str): The base64 encoded string of the image.
-
-        Returns:
-            Optional[Image.Image]: The PIL Image object or None if conversion
-                fails.
-        """
-        try:
-            # Decode the base64 string to get the image data
-            image_data = base64.b64decode(base64_string)
-            # Create a memory buffer for the image data
-            image_buffer = BytesIO(image_data)
-            # Open the image using the PIL library
-            image = Image.open(image_buffer)
-            return image
-        except Exception as e:
-            error_msg = (
-                f"An error occurred while converting base64 to image: {e}"
-            )
-            logger.error(error_msg)
-            return None
-
-    def image_path_to_base64(self, image_path: str) -> str:
-        r"""Converts the file path of an image to a Base64 encoded string.
-
-        Args:
-            image_path (str): The path to the image file.
-
-        Returns:
-            str: A Base64 encoded string representing the content of the image
-                file.
-        """
-        try:
-            with open(image_path, "rb") as image_file:
-                return base64.b64encode(image_file.read()).decode('utf-8')
-        except Exception as e:
-            error_msg = (
-                f"An error occurred while converting image path to base64: {e}"
-            )
-            logger.error(error_msg)
-            return error_msg
-
-    def image_to_base64(self, image: Image.Image) -> str:
-        r"""Converts an image into a base64-encoded string.
-
-        This function takes an image object as input, encodes the image into a
-        PNG format base64 string, and returns it.
-        If the encoding process encounters an error, it prints the error
-        message and returns None.
-
-        Args:
-            image: The image object to be encoded, supports any image format
-                that can be saved in PNG format.
-
-        Returns:
-            str: A base64-encoded string of the image.
-        """
-        try:
-            with BytesIO() as buffered_image:
-                image.save(buffered_image, format="PNG")
-                buffered_image.seek(0)
-                image_bytes = buffered_image.read()
-                base64_str = base64.b64encode(image_bytes).decode('utf-8')
-                return base64_str
-        except Exception as e:
-            error_msg = f"An error occurred: {e}"
-            logger.error(error_msg)
-            return error_msg
-
-    def get_dalle_img(self, prompt: str, image_dir: str = "img") -> str:
-        r"""Generate an image using OpenAI's DALL-E model.
-            The generated image is saved to the specified directory.
-
-        Args:
-            prompt (str): The text prompt based on which the image is
-                generated.
-            image_dir (str): The directory to save the generated image.
-                Defaults to 'img'.
-
-        Returns:
-            str: The path to the saved image.
-        """
-
-        dalle_client = OpenAI()
-        response = dalle_client.images.generate(
-            model="dall-e-3",
-            prompt=prompt,
-            size="1024x1792",
-            quality="standard",
-            n=1,  # NOTE: now dall-e-3 only supports n=1
-            response_format="b64_json",
-        )
-        if response.data is None or len(response.data) == 0:
-            error_msg = "No image data returned from DALL-E API."
-            logger.error(error_msg)
-            return error_msg
-        image_b64 = response.data[0].b64_json
-        image = self.base64_to_image(image_b64)  # type: ignore[arg-type]
-
-        if image is None:
-            error_msg = "Failed to convert base64 string to image."
-            logger.error(error_msg)
-            return error_msg
-
-        os.makedirs(image_dir, exist_ok=True)
-        image_path = os.path.join(image_dir, f"{uuid.uuid4()}.png")
-        image.save(image_path)
-
-        return image_path
-
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of FunctionTool objects representing the
-        functions in the toolkit.
-
-        Returns:
-            List[FunctionTool]: A list of FunctionTool objects
-                representing the functions in the toolkit.
-        """
-        return [FunctionTool(self.get_dalle_img)]