camel-ai 0.2.0__py3-none-any.whl → 0.2.3a0__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/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/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 = [
@@ -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': output_schema.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:

camel/loaders/unstructured_io.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import uuid
 import warnings
+from io import IOBase
 from typing import (
     Any,
     Dict,
@@ -108,7 +109,7 @@ class UnstructuredIO:
                 specified.
 
         Notes:
-            Available document types:
+            Supported file types:
                 "csv", "doc", "docx", "epub", "image", "md", "msg", "odt",
                 "org", "pdf", "ppt", "pptx", "rtf", "rst", "tsv", "xlsx".
 
@@ -152,6 +153,39 @@ class UnstructuredIO:
                 warnings.warn(f"Failed to partition the file: {input_path}")
                 return None
 
+    @staticmethod
+    def parse_bytes(file: IOBase, **kwargs: Any) -> Union[List[Element], None]:
+        r"""Parses a bytes stream and converts its contents into elements.
+
+        Args:
+            file (IOBase): The file in bytes format to be parsed.
+            **kwargs: Extra kwargs passed to the partition function.
+
+        Returns:
+            Union[List[Element], None]: List of elements after parsing the file
+                if successful, otherwise `None`.
+
+        Notes:
+            Supported file types:
+                "csv", "doc", "docx", "epub", "image", "md", "msg", "odt",
+                "org", "pdf", "ppt", "pptx", "rtf", "rst", "tsv", "xlsx".
+
+        References:
+            https://docs.unstructured.io/open-source/core-functionality/partitioning
+        """
+
+        from unstructured.partition.auto import partition
+
+        try:
+            # Use partition to process the bytes stream
+            elements = partition(file=file, **kwargs)
+            return elements
+        except Exception as e:
+            import warnings
+
+            warnings.warn(f"Failed to partition the file stream: {e}")
+            return None
+
     @staticmethod
     def clean_text_data(
         text: str,

camel/messages/func_message.py

@@ -93,10 +93,10 @@ class FunctionCallingMessage(BaseMessage):
             OpenAIMessage: The converted :obj:`OpenAIMessage` object
                 with its role being "function".
         """
-        if (not self.func_name) or (not self.result):
+        if not self.func_name:
             raise ValueError(
                 "Invalid request for converting into function message"
-                " due to missing function name or results."
+                " due to missing function name."
             )
 
         result_content = {"result": {str(self.result)}}

camel/models/mistral_model.py

@@ -93,7 +93,7 @@ class MistralModel(BaseModelBackend):
                         "name": tool_call.function.name,  # type: ignore[union-attr]
                         "arguments": tool_call.function.arguments,  # type: ignore[union-attr]
                     },
-                    type=tool_call.TYPE,  # type: ignore[union-attr]
+                    type=tool_call.type,  # type: ignore[union-attr]
                 )
                 for tool_call in response.choices[0].message.tool_calls
             ]

camel/models/openai_compatibility_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
+import os
 from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
@@ -25,14 +26,14 @@ from camel.utils import (
 
 
 class OpenAICompatibilityModel:
-    r"""Constructor for model backend supporting OpenAI compatibility."""
+    r"""LLM API served by OpenAI-compatible providers."""
 
     def __init__(
         self,
         model_type: str,
         model_config_dict: Dict[str, Any],
-        api_key: str,
-        url: str,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
         r"""Constructor for model backend.
@@ -51,13 +52,25 @@ class OpenAICompatibilityModel:
         """
         self.model_type = model_type
         self.model_config_dict = model_config_dict
-        self._token_counter = token_counter
+        self._url = url or os.environ.get("OPENAI_COMPATIBILIY_API_BASE_URL")
+        self._api_key = api_key or os.environ.get(
+            "OPENAI_COMPATIBILIY_API_KEY"
+        )
+        if self._url is None:
+            raise ValueError(
+                "For OpenAI-compatible models, you must provide the `url`."
+            )
+        if self._api_key is None:
+            raise ValueError(
+                "For OpenAI-compatible models, you must provide the `api_key`."
+            )
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            api_key=api_key,
-            base_url=url,
+            base_url=self._url,
+            api_key=self._api_key,
         )
+        self._token_counter = token_counter
 
     def run(
         self,

camel/retrievers/vector_retriever.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
 import warnings
+from io import IOBase
 from typing import Any, Dict, List, Optional, Union
 from urllib.parse import urlparse
 
@@ -72,26 +73,34 @@ class VectorRetriever(BaseRetriever):
 
     def process(
         self,
-        content: Union[str, Element],
+        content: Union[str, Element, IOBase],
         chunk_type: str = "chunk_by_title",
         max_characters: int = 500,
+        embed_batch: int = 50,
+        should_chunk: bool = True,
         **kwargs: Any,
     ) -> None:
-        r"""Processes content from a file or URL, divides it into chunks by
-        using `Unstructured IO`, and stores their embeddings in the specified
-        vector storage.
+        r"""Processes content from local file path, remote URL, string
+        content, Element object, or a binary file object, divides it into
+        chunks by using `Unstructured IO`, and stores their embeddings in the
+        specified vector storage.
 
         Args:
-            content (Union[str, Element]): Local file path, remote URL,
-                string content or Element object.
+            content (Union[str, Element, IOBase]): Local file path, remote
+                URL, string content, Element object, or a binary file object.
             chunk_type (str): Type of chunking going to apply. Defaults to
                 "chunk_by_title".
             max_characters (int): Max number of characters in each chunk.
                 Defaults to `500`.
+            embed_batch (int): Size of batch for embeddings. Defaults to `50`.
+            should_chunk (bool): If True, divide the content into chunks,
+                otherwise skip chunking. Defaults to True.
             **kwargs (Any): Additional keyword arguments for content parsing.
         """
         if isinstance(content, Element):
             elements = [content]
+        elif isinstance(content, IOBase):
+            elements = self.uio.parse_bytes(file=content, **kwargs) or []
         else:
             # Check if the content is URL
             parsed_url = urlparse(content)
@@ -100,20 +109,26 @@ class VectorRetriever(BaseRetriever):
                 elements = self.uio.parse_file_or_url(content, **kwargs) or []
             else:
                 elements = [self.uio.create_element_from_text(text=content)]
-        if elements:
-            chunks = self.uio.chunk_elements(
-                chunk_type=chunk_type,
-                elements=elements,
-                max_characters=max_characters,
-            )
         if not elements:
             warnings.warn(
                 f"No elements were extracted from the content: {content}"
             )
             return
-        # Iterate to process and store embeddings, set batch of 50
-        for i in range(0, len(chunks), 50):
-            batch_chunks = chunks[i : i + 50]
+
+        # Chunk the content if required
+        chunks = (
+            self.uio.chunk_elements(
+                chunk_type=chunk_type,
+                elements=elements,
+                max_characters=max_characters,
+            )
+            if should_chunk
+            else elements
+        )
+
+        # Process chunks in batches and store embeddings
+        for i in range(0, len(chunks), embed_batch):
+            batch_chunks = chunks[i : i + embed_batch]
             batch_vectors = self.embedding_model.embed_list(
                 objs=[str(chunk) for chunk in batch_chunks]
             )
@@ -124,6 +139,8 @@ class VectorRetriever(BaseRetriever):
             for vector, chunk in zip(batch_vectors, batch_chunks):
                 if isinstance(content, str):
                     content_path_info = {"content path": content}
+                elif isinstance(content, IOBase):
+                    content_path_info = {"content path": "From file bytes"}
                 elif isinstance(content, Element):
                     content_path_info = {
                         "content path": content.metadata.file_directory

camel/societies/role_playing.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+import logging
 from typing import Dict, List, Optional, Sequence, Tuple, Union
 
 from camel.agents import (
@@ -27,6 +28,9 @@ from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
 from camel.types import RoleType, TaskType
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.WARNING)
+
 
 class RolePlaying:
     r"""Role playing between two agents.
@@ -97,6 +101,14 @@ class RolePlaying:
         extend_task_specify_meta_dict: Optional[Dict] = None,
         output_language: Optional[str] = None,
     ) -> None:
+        if model is not None:
+            logger.warning(
+                "The provided model will override the model settings in "
+                "all agents, including any configurations passed "
+                "through assistant_agent_kwargs, user_agent_kwargs, and "
+                "other agent-specific kwargs."
+            )
+
         self.with_task_specify = with_task_specify
         self.with_task_planner = with_task_planner
         self.with_critic_in_the_loop = with_critic_in_the_loop

camel/storages/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .graph_storages.base import BaseGraphStorage
+from .graph_storages.nebula_graph import NebulaGraph
 from .graph_storages.neo4j_graph import Neo4jGraph
 from .key_value_storages.base import BaseKeyValueStorage
 from .key_value_storages.in_memory import InMemoryKeyValueStorage
@@ -40,4 +41,5 @@ __all__ = [
     'MilvusStorage',
     'BaseGraphStorage',
     'Neo4jGraph',
+    'NebulaGraph',
 ]

camel/storages/graph_storages/__init__.py

@@ -14,10 +14,12 @@
 
 from .base import BaseGraphStorage
 from .graph_element import GraphElement
+from .nebula_graph import NebulaGraph
 from .neo4j_graph import Neo4jGraph
 
 __all__ = [
     'BaseGraphStorage',
     'GraphElement',
     'Neo4jGraph',
+    'NebulaGraph',
 ]