camel-ai 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

camel/bots/telegram_bot.py

@@ -0,0 +1,82 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import os
+from typing import TYPE_CHECKING, Optional
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+from camel.utils import dependencies_required
+
+# Conditionally import telebot types only for type checking
+if TYPE_CHECKING:
+    from telebot.types import (  # type: ignore[import-untyped]
+        Message,
+    )
+
+
+class TelegramBot:
+    r"""Represents a Telegram bot that is powered by an agent.
+
+    Attributes:
+        chat_agent (ChatAgent): Chat agent that will power the bot.
+        telegram_token (str, optional): The bot token.
+    """
+
+    @dependencies_required('telebot')
+    def __init__(
+        self,
+        chat_agent: ChatAgent,
+        telegram_token: Optional[str] = None,
+    ) -> None:
+        self.chat_agent = chat_agent
+
+        if not telegram_token:
+            self.token = os.getenv('TELEGRAM_TOKEN')
+            if not self.token:
+                raise ValueError(
+                    "`TELEGRAM_TOKEN` not found in environment variables. "
+                    "Get it from t.me/BotFather."
+                )
+        else:
+            self.token = telegram_token
+
+        import telebot  # type: ignore[import-untyped]
+
+        self.bot = telebot.TeleBot(token=self.token)
+
+        # Register the message handler within the constructor
+        self.bot.message_handler(func=lambda message: True)(self.on_message)
+
+    def run(self) -> None:
+        r"""Start the Telegram bot."""
+        print("Telegram bot is running...")
+        self.bot.infinity_polling()
+
+    def on_message(self, message: 'Message') -> None:
+        r"""Handles incoming messages from the user.
+
+        Args:
+            message (types.Message): The incoming message object.
+        """
+        self.chat_agent.reset()
+
+        if not message.text:
+            return
+
+        user_msg = BaseMessage.make_user_message(
+            role_name="User", content=message.text
+        )
+        assistant_response = self.chat_agent.step(user_msg)
+
+        self.bot.reply_to(message, assistant_response.msg.content)

camel/configs/__init__.py

@@ -18,7 +18,7 @@ from .groq_config import GROQ_API_PARAMS, GroqConfig
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
-from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig, OpenSourceConfig
+from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig
 from .reka_config import REKA_API_PARAMS, RekaConfig
 from .samba_config import (
     SAMBA_CLOUD_API_PARAMS,
@@ -40,7 +40,6 @@ __all__ = [
     'ANTHROPIC_API_PARAMS',
     'GROQ_API_PARAMS',
     'GroqConfig',
-    'OpenSourceConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
     'OllamaConfig',

camel/configs/anthropic_config.py

@@ -15,9 +15,8 @@ from __future__ import annotations
 
 from typing import List, Union
 
-from anthropic import NOT_GIVEN, NotGiven
-
 from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
 
 
 class AnthropicConfig(BaseConfig):
@@ -55,9 +54,7 @@ class AnthropicConfig(BaseConfig):
             (default: :obj:`5`)
         metadata: An object describing metadata about the request.
         stream (bool, optional): Whether to incrementally stream the response
-          using server-sent events.
-            (default: :obj:`False`)
-
+            using server-sent events. (default: :obj:`False`)
     """
 
     max_tokens: int = 256

camel/configs/base_config.py

@@ -39,13 +39,13 @@ class BaseConfig(ABC, BaseModel):
     @classmethod
     def fields_type_checking(cls, tools):
         if tools is not None:
-            from camel.toolkits import OpenAIFunction
+            from camel.toolkits import FunctionTool
 
             for tool in tools:
-                if not isinstance(tool, OpenAIFunction):
+                if not isinstance(tool, FunctionTool):
                     raise ValueError(
                         f"The tool {tool} should "
-                        "be an instance of `OpenAIFunction`."
+                        "be an instance of `FunctionTool`."
                     )
         return tools
 
@@ -54,14 +54,14 @@ class BaseConfig(ABC, BaseModel):
 
         tools_schema = None
         if self.tools:
-            from camel.toolkits import OpenAIFunction
+            from camel.toolkits import FunctionTool
 
             tools_schema = []
             for tool in self.tools:
-                if not isinstance(tool, OpenAIFunction):
+                if not isinstance(tool, FunctionTool):
                     raise ValueError(
                         f"The tool {tool} should "
-                        "be an instance of `OpenAIFunction`."
+                        "be an instance of `FunctionTool`."
                     )
                 tools_schema.append(tool.get_openai_tool_schema())
         config_dict["tools"] = tools_schema

camel/configs/gemini_config.py

@@ -86,7 +86,7 @@ class GeminiConfig(BaseConfig):
 
     @model_validator(mode="before")
     @classmethod
-    def fields_type_checking(cls, data: Any):
+    def model_type_checking(cls, data: Any):
         if isinstance(data, dict):
             response_schema = data.get("response_schema")
             safety_settings = data.get("safety_settings")

camel/configs/groq_config.py

@@ -15,9 +15,8 @@ from __future__ import annotations
 
 from typing import Optional, Sequence, Union
 
-from openai._types import NOT_GIVEN, NotGiven
-
 from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
 
 
 class GroqConfig(BaseConfig):
@@ -73,7 +72,7 @@ class GroqConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[OpenAIFunction], optional): A list of tools the model may
+        tools (list[FunctionTool], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/configs/ollama_config.py

@@ -15,9 +15,8 @@ from __future__ import annotations
 
 from typing import Sequence, Union
 
-from openai._types import NOT_GIVEN, NotGiven
-
 from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
 
 
 class OllamaConfig(BaseConfig):

camel/configs/openai_config.py

@@ -15,10 +15,10 @@ from __future__ import annotations
 
 from typing import Optional, Sequence, Union
 
-from openai._types import NOT_GIVEN, NotGiven
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
 
 
 class ChatGPTConfig(BaseConfig):
@@ -81,7 +81,7 @@ class ChatGPTConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[OpenAIFunction], optional): A list of tools the model may
+        tools (list[FunctionTool], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.
@@ -112,24 +112,3 @@ class ChatGPTConfig(BaseConfig):
 
 
 OPENAI_API_PARAMS = {param for param in ChatGPTConfig.model_fields.keys()}
-
-
-class OpenSourceConfig(BaseConfig):
-    r"""Defines parameters for setting up open-source models and includes
-    parameters to be passed to chat completion function of OpenAI API.
-
-    Args:
-        model_path (str): The path to a local folder containing the model
-            files or the model card in HuggingFace hub.
-        server_url (str): The URL to the server running the model inference
-            which will be used as the API base of OpenAI API.
-        api_params (ChatGPTConfig): An instance of :obj:ChatGPTConfig to
-            contain the arguments to be passed to OpenAI API.
-    """
-
-    # Maybe the param needs to be renamed.
-    # Warning: Field "model_path" has conflict with protected namespace
-    # "model_".
-    model_path: str
-    server_url: str
-    api_params: ChatGPTConfig = Field(default_factory=ChatGPTConfig)

camel/configs/samba_config.py

@@ -15,10 +15,10 @@ from __future__ import annotations
 
 from typing import Any, Dict, Optional, Sequence, Union
 
-from openai._types import NOT_GIVEN, NotGiven
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
 
 
 class SambaFastAPIConfig(BaseConfig):
@@ -172,7 +172,7 @@ class SambaCloudAPIConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[OpenAIFunction], optional): A list of tools the model may
+        tools (list[FunctionTool], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/configs/togetherai_config.py

@@ -15,10 +15,10 @@ from __future__ import annotations
 
 from typing import Any, Sequence, Union
 
-from openai._types import NOT_GIVEN, NotGiven
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
 
 
 class TogetherAIConfig(BaseConfig):

camel/configs/vllm_config.py

@@ -15,10 +15,10 @@ from __future__ import annotations
 
 from typing import Sequence, Union
 
-from openai._types import NOT_GIVEN, NotGiven
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
 
 
 # flake8: noqa: E501

camel/configs/zhipuai_config.py

@@ -15,9 +15,8 @@ from __future__ import annotations
 
 from typing import Optional, Sequence, Union
 
-from openai._types import NOT_GIVEN, NotGiven
-
 from camel.configs.base_config import BaseConfig
+from camel.types import NOT_GIVEN, NotGiven
 
 
 class ZhipuAIConfig(BaseConfig):
@@ -45,7 +44,7 @@ class ZhipuAIConfig(BaseConfig):
             in the chat completion. The total length of input tokens and
             generated tokens is limited by the model's context length.
             (default: :obj:`None`)
-        tools (list[OpenAIFunction], optional): A list of tools the model may
+        tools (list[FunctionTool], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/embeddings/openai_embedding.py

@@ -16,10 +16,10 @@ from __future__ import annotations
 import os
 from typing import Any
 
-from openai import NOT_GIVEN, NotGiven, OpenAI
+from openai import OpenAI
 
 from camel.embeddings.base import BaseEmbedding
-from camel.types import EmbeddingModelType
+from camel.types import NOT_GIVEN, EmbeddingModelType, NotGiven
 from camel.utils import api_keys_required
 
 

camel/loaders/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .base_io import File
+from .chunkr_reader import ChunkrReader
 from .firecrawl_reader import Firecrawl
 from .jina_url_reader import JinaURLReader
 from .unstructured_io import UnstructuredIO
@@ -22,4 +23,5 @@ __all__ = [
     'UnstructuredIO',
     'JinaURLReader',
     'Firecrawl',
+    'ChunkrReader',
 ]

camel/loaders/chunkr_reader.py

@@ -0,0 +1,163 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+import json
+import logging
+import os
+import time
+from typing import IO, Any, Optional, Union
+
+import requests
+
+from camel.utils import api_keys_required
+
+logger = logging.getLogger(__name__)
+
+
+class ChunkrReader:
+    r"""Chunkr Reader for processing documents and returning content
+    in various formats.
+
+    Args:
+        api_key (Optional[str], optional): The API key for Chunkr API. If not
+            provided, it will be retrieved from the environment variable
+            `CHUNKR_API_KEY`. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Chunkr service.
+            (default: :obj:`https://api.chunkr.ai/api/v1/task`)
+        timeout (int, optional): The maximum time in seconds to wait for the
+            API responses. (default: :obj:`30`)
+        **kwargs (Any): Additional keyword arguments for request headers.
+    """
+
+    @api_keys_required("CHUNKR_API_KEY")
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        url: Optional[str] = "https://api.chunkr.ai/api/v1/task",
+        timeout: int = 30,
+        **kwargs: Any,
+    ) -> None:
+        self._api_key = api_key or os.getenv('CHUNKR_API_KEY')
+        self._url = os.getenv('CHUNKR_API_URL') or url
+        self._headers = {
+            "Authorization": f"{self._api_key}",
+            **kwargs,
+        }
+        self.timeout = timeout
+
+    def submit_task(
+        self,
+        file_path: str,
+        model: str = "Fast",
+        ocr_strategy: str = "Auto",
+        target_chunk_length: str = "512",
+    ) -> str:
+        r"""Submits a file to the Chunkr API and returns the task ID.
+
+        Args:
+            file_path (str): The path to the file to be uploaded.
+            model (str, optional): The model to be used for the task.
+                (default: :obj:`Fast`)
+            ocr_strategy (str, optional): The OCR strategy. Defaults to 'Auto'.
+            target_chunk_length (str, optional): The target chunk length.
+                (default: :obj:`512`)
+
+        Returns:
+            str: The task ID.
+        """
+        with open(file_path, 'rb') as file:
+            files: dict[
+                str, Union[tuple[None, IO[bytes]], tuple[None, str]]
+            ] = {
+                'file': (
+                    None,
+                    file,
+                ),  # Properly pass the file as a binary stream
+                'model': (None, model),
+                'ocr_strategy': (None, ocr_strategy),
+                'target_chunk_length': (None, target_chunk_length),
+            }
+            try:
+                response = requests.post(
+                    self._url,  # type: ignore[arg-type]
+                    headers=self._headers,
+                    files=files,
+                    timeout=self.timeout,
+                )
+                response.raise_for_status()
+                task_id = response.json().get('task_id')
+                if not task_id:
+                    raise ValueError("Task ID not returned in the response.")
+                logger.info(f"Task submitted successfully. Task ID: {task_id}")
+                return task_id
+            except Exception as e:
+                logger.error(f"Failed to submit task: {e}")
+                raise ValueError(f"Failed to submit task: {e}") from e
+
+    def get_task_output(self, task_id: str, max_retries: int = 5) -> str:
+        r"""Polls the Chunkr API to check the task status and returns the task
+        result.
+
+        Args:
+            task_id (str): The task ID to check the status for.
+            max_retries (int, optional): Maximum number of retry attempts.
+                (default: :obj:`5`)
+
+        Returns:
+            str: The formatted task result in JSON format.
+
+        Raises:
+            ValueError: If the task status cannot be retrieved.
+            RuntimeError: If the maximum number of retries is reached without
+                a successful task completion.
+        """
+        url_get = f"{self._url}/{task_id}"
+        attempts = 0
+
+        while attempts < max_retries:
+            try:
+                response = requests.get(
+                    url_get, headers=self._headers, timeout=self.timeout
+                )
+                response.raise_for_status()
+                task_status = response.json().get('status')
+
+                if task_status == "Succeeded":
+                    logger.info(f"Task {task_id} completed successfully.")
+                    return self._pretty_print_response(response.json())
+                else:
+                    logger.info(
+                        f"Task {task_id} is still {task_status}. Retrying "
+                        "in 5 seconds..."
+                    )
+            except Exception as e:
+                logger.error(f"Failed to retrieve task status: {e}")
+                raise ValueError(f"Failed to retrieve task status: {e}") from e
+
+            attempts += 1
+            time.sleep(5)
+
+        logger.error(f"Max retries reached for task {task_id}.")
+        raise RuntimeError(f"Max retries reached for task {task_id}.")
+
+    def _pretty_print_response(self, response_json: dict) -> str:
+        r"""Pretty prints the JSON response.
+
+        Args:
+            response_json (dict): The response JSON to pretty print.
+
+        Returns:
+            str: Formatted JSON as a string.
+        """
+        return json.dumps(response_json, indent=4)

camel/loaders/firecrawl_reader.py

@@ -49,7 +49,6 @@ class Firecrawl:
         self,
         url: str,
         params: Optional[Dict[str, Any]] = None,
-        wait_until_done: bool = True,
         **kwargs: Any,
     ) -> Any:
         r"""Crawl a URL and all accessible subpages. Customize the crawl by
@@ -60,14 +59,12 @@ class Firecrawl:
             url (str): The URL to crawl.
             params (Optional[Dict[str, Any]]): Additional parameters for the
                 crawl request. Defaults to `None`.
-            wait_until_done (bool): Whether to wait until the crawl job is
-                completed. Defaults to `True`.
             **kwargs (Any): Additional keyword arguments, such as
-                `poll_interval`, `idempotency_key`, etc.
+                `poll_interval`, `idempotency_key`.
 
         Returns:
-            Any: The list content of the URL if `wait_until_done` is True;
-                otherwise, a string job ID.
+            Any: The crawl job ID or the crawl results if waiting until
+                completion.
 
         Raises:
             RuntimeError: If the crawling process fails.
@@ -78,13 +75,8 @@ class Firecrawl:
                 url=url,
                 params=params,
                 **kwargs,
-                wait_until_done=wait_until_done,
-            )
-            return (
-                crawl_response
-                if wait_until_done
-                else crawl_response.get("jobId")
             )
+            return crawl_response
         except Exception as e:
             raise RuntimeError(f"Failed to crawl the URL: {e}")
 
@@ -103,7 +95,10 @@ class Firecrawl:
         """
 
         try:
-            crawl_result = self.app.crawl_url(url=url)
+            crawl_result = self.app.crawl_url(
+                url,
+                {'formats': ['markdown']},
+            )
             if not isinstance(crawl_result, list):
                 raise ValueError("Unexpected response format")
             markdown_contents = [
@@ -160,12 +155,12 @@ class Firecrawl:
         except Exception as e:
             raise RuntimeError(f"Failed to scrape the URL: {e}")
 
-    def structured_scrape(self, url: str, output_schema: BaseModel) -> Dict:
+    def structured_scrape(self, url: str, response_format: BaseModel) -> Dict:
         r"""Use LLM to extract structured data from given URL.
 
         Args:
             url (str): The URL to read.
-            output_schema (BaseModel): A pydantic model
+            response_format (BaseModel): A pydantic model
                 that includes value types and field descriptions used to
                 generate a structured response by LLM. This schema helps
                 in defining the expected output format.
@@ -180,41 +175,14 @@ class Firecrawl:
             data = self.app.scrape_url(
                 url,
                 {
-                    'extractorOptions': {
-                        "mode": "llm-extraction",
-                        "extractionPrompt": "Based on the information on "
-                        "the page, extract the information from the schema.",
-                        'extractionSchema': output_schema.model_json_schema(),
-                    },
-                    'pageOptions': {'onlyMainContent': True},
+                    'formats': ['extract'],
+                    'extract': {'schema': response_format.model_json_schema()},
                 },
             )
-            return data.get("llm_extraction", {})
+            return data.get("extract", {})
         except Exception as e:
             raise RuntimeError(f"Failed to perform structured scrape: {e}")
 
-    def tidy_scrape(self, url: str) -> str:
-        r"""Only return the main content of the page, excluding headers,
-        navigation bars, footers, etc. in Markdown format.
-
-        Args:
-            url (str): The URL to read.
-
-        Returns:
-            str: The markdown content of the URL.
-
-        Raises:
-            RuntimeError: If the scrape process fails.
-        """
-
-        try:
-            scrape_result = self.app.scrape_url(
-                url, {'pageOptions': {'onlyMainContent': True}}
-            )
-            return scrape_result.get("markdown", "")
-        except Exception as e:
-            raise RuntimeError(f"Failed to perform tidy scrape: {e}")
-
     def map_site(
         self, url: str, params: Optional[Dict[str, Any]] = None
     ) -> list: