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

camel/models/zhipuai_model.py

@@ -17,14 +17,10 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import ZHIPUAI_API_PARAMS, ZhipuAIConfig
+from camel.configs import ZHIPUAI_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
-from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ModelType,
-)
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
@@ -33,42 +29,40 @@ from camel.utils import (
 
 
 class ZhipuAIModel(BaseModelBackend):
-    r"""ZhipuAI API in a unified BaseModelBackend interface.
-
-    Args:
-        model_type (Union[ModelType, str]): Model for which a backend is
-            created, one of GLM_* series.
-        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into:obj:`openai.ChatCompletion.create()`. If
-            :obj:`None`, :obj:`ZhipuAIConfig().as_dict()` will be used.
-            (default: :obj:`None`)
-        api_key (Optional[str], optional): The API key for authenticating with
-            the ZhipuAI service. (default: :obj:`None`)
-        url (Optional[str], optional): The url to the ZhipuAI service.
-            (default: :obj:`https://open.bigmodel.cn/api/paas/v4/`)
-        token_counter (Optional[BaseTokenCounter], optional): Token counter to
-            use for the model. If not provided, :obj:`OpenAITokenCounter(
-            ModelType.GPT_4O_MINI)` will be used.
-            (default: :obj:`None`)
-    """
+    r"""ZhipuAI API in a unified BaseModelBackend interface."""
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        if model_config_dict is None:
-            model_config_dict = ZhipuAIConfig().as_dict()
-        api_key = api_key or os.environ.get("ZHIPUAI_API_KEY")
-        url = url or os.environ.get(
-            "ZHIPUAI_API_BASE_URL", "https://open.bigmodel.cn/api/paas/v4/"
-        )
+        r"""Constructor for ZhipuAI backend.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created,
+                such as GLM_* series.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into openai.ChatCompletion.create().
+            api_key (Optional[str]): The API key for authenticating with the
+                ZhipuAI service. (default: :obj:`None`)
+            url (Optional[str]): The url to the ZhipuAI service. (default:
+                :obj:`None`)
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `OpenAITokenCounter(ModelType.
+                GPT_4O_MINI)` will be used.
+        """
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
+        self._url = url or os.environ.get("ZHIPUAI_API_BASE_URL")
+        self._api_key = api_key or os.environ.get("ZHIPUAI_API_KEY")
+        if not self._url or not self._api_key:
+            raise ValueError(
+                "ZHIPUAI_API_BASE_URL and ZHIPUAI_API_KEY should be set."
+            )
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
@@ -96,7 +90,7 @@ class ZhipuAIModel(BaseModelBackend):
         # Reference: https://open.bigmodel.cn/dev/api#openai_sdk
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model_type,
+            model=self.model_type.value,
             **self.model_config_dict,
         )
         return response

camel/retrievers/auto_retriever.py

@@ -14,16 +14,7 @@
 import datetime
 import os
 import re
-import uuid
-from typing import (
-    TYPE_CHECKING,
-    Collection,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
-)
+from typing import Collection, List, Optional, Sequence, Tuple, Union
 
 from camel.embeddings import BaseEmbedding, OpenAIEmbedding
 from camel.retrievers.vector_retriever import VectorRetriever
@@ -36,8 +27,10 @@ from camel.storages import (
 from camel.types import StorageType
 from camel.utils import Constants
 
-if TYPE_CHECKING:
+try:
     from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
 
 
 class AutoRetriever:
@@ -105,9 +98,7 @@ class AutoRetriever:
             f"Unsupported vector storage type: {self.storage_type}"
         )
 
-    def _collection_name_generator(
-        self, content: Union[str, "Element"]
-    ) -> str:
+    def _collection_name_generator(self, content: Union[str, Element]) -> str:
         r"""Generates a valid collection name from a given file path or URL.
 
         Args:
@@ -117,10 +108,9 @@ class AutoRetriever:
         Returns:
             str: A sanitized, valid collection name suitable for use.
         """
-        from unstructured.documents.elements import Element
 
         if isinstance(content, Element):
-            content = content.metadata.file_directory or str(uuid.uuid4())
+            content = content.metadata.file_directory
 
         collection_name = re.sub(r'[^a-zA-Z0-9]', '', content)[:20]
 
@@ -185,7 +175,7 @@ class AutoRetriever:
     def run_vector_retriever(
         self,
         query: str,
-        contents: Union[str, List[str], "Element", List["Element"]],
+        contents: Union[str, List[str], Element, List[Element]],
         top_k: int = Constants.DEFAULT_TOP_K_RESULTS,
         similarity_threshold: float = Constants.DEFAULT_SIMILARITY_THRESHOLD,
         return_detailed_info: bool = False,
@@ -222,20 +212,12 @@ class AutoRetriever:
                 `contents` is empty.
             RuntimeError: If any errors occur during the retrieve process.
         """
-        from unstructured.documents.elements import Element
-
         if not contents:
             raise ValueError("content cannot be empty.")
 
-        # Normalize contents to a list
-        if isinstance(contents, str):
-            contents = [contents]
-        elif isinstance(contents, Element):
-            contents = [contents]
-        elif not isinstance(contents, list):
-            raise ValueError(
-                "contents must be a string, Element, or a list of them."
-            )
+        contents = (
+            [contents] if isinstance(contents, (str, Element)) else contents
+        )
 
         all_retrieved_info = []
         for content in contents:

camel/retrievers/vector_retriever.py

@@ -14,7 +14,7 @@
 import os
 import warnings
 from io import IOBase
-from typing import IO, TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from urllib.parse import urlparse
 
 from camel.embeddings import BaseEmbedding, OpenAIEmbedding
@@ -28,8 +28,10 @@ from camel.storages import (
 )
 from camel.utils import Constants
 
-if TYPE_CHECKING:
+try:
     from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
 
 
 class VectorRetriever(BaseRetriever):
@@ -71,7 +73,7 @@ class VectorRetriever(BaseRetriever):
 
     def process(
         self,
-        content: Union[str, "Element", IO[bytes]],
+        content: Union[str, Element, IOBase],
         chunk_type: str = "chunk_by_title",
         max_characters: int = 500,
         embed_batch: int = 50,
@@ -84,7 +86,7 @@ class VectorRetriever(BaseRetriever):
         specified vector storage.
 
         Args:
-            content (Union[str, Element, IO[bytes]]): Local file path, remote
+            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".
@@ -95,73 +97,67 @@ class VectorRetriever(BaseRetriever):
                 otherwise skip chunking. Defaults to True.
             **kwargs (Any): Additional keyword arguments for content parsing.
         """
-        from unstructured.documents.elements import Element
-
         if isinstance(content, Element):
             elements = [content]
         elif isinstance(content, IOBase):
             elements = self.uio.parse_bytes(file=content, **kwargs) or []
-        elif isinstance(content, str):
+        else:
             # Check if the content is URL
             parsed_url = urlparse(content)
             is_url = all([parsed_url.scheme, parsed_url.netloc])
             if is_url or os.path.exists(content):
-                elements = (
-                    self.uio.parse_file_or_url(input_path=content, **kwargs)
-                    or []
-                )
+                elements = self.uio.parse_file_or_url(content, **kwargs) or []
             else:
                 elements = [self.uio.create_element_from_text(text=content)]
-
         if not elements:
             warnings.warn(
                 f"No elements were extracted from the content: {content}"
             )
-        else:
-            # 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
+            return
+
+        # 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]
-                )
+        # 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]
+            )
 
-                records = []
-                # Prepare the payload for each vector record, includes the
-                # content path, chunk metadata, and chunk text
-                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
-                            or ""
-                        }
-                    chunk_metadata = {"metadata": chunk.metadata.to_dict()}
-                    chunk_text = {"text": str(chunk)}
-                    combined_dict = {
-                        **content_path_info,
-                        **chunk_metadata,
-                        **chunk_text,
+            records = []
+            # Prepare the payload for each vector record, includes the content
+            # path, chunk metadata, and chunk text
+            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
                     }
+                chunk_metadata = {"metadata": chunk.metadata.to_dict()}
+                chunk_text = {"text": str(chunk)}
+                combined_dict = {
+                    **content_path_info,
+                    **chunk_metadata,
+                    **chunk_text,
+                }
 
-                    records.append(
-                        VectorRecord(vector=vector, payload=combined_dict)
-                    )
+                records.append(
+                    VectorRecord(vector=vector, payload=combined_dict)
+                )
 
-                self.storage.add(records=records)
+            self.storage.add(records=records)
 
     def query(
         self,
@@ -199,13 +195,6 @@ class VectorRetriever(BaseRetriever):
         db_query = VectorDBQuery(query_vector=query_vector, top_k=top_k)
         query_results = self.storage.query(query=db_query)
 
-        # If no results found, raise an error
-        if not query_results:
-            raise ValueError(
-                "Query result is empty, please check if "
-                "the vector storage is empty."
-            )
-
         if query_results[0].record.payload is None:
             raise ValueError(
                 "Payload of vector storage is None, please check the "

camel/societies/babyagi_playing.py

@@ -106,7 +106,7 @@ class BabyAGI:
         )
 
         self.assistant_agent: ChatAgent
-        self.assistant_sys_msg: Optional[BaseMessage]
+        self.assistant_sys_msg: BaseMessage
         self.task_creation_agent: TaskCreationAgent
         self.task_prioritization_agent: TaskPrioritizationAgent
         self.init_agents(
@@ -202,8 +202,7 @@ class BabyAGI:
 
         self.task_creation_agent = TaskCreationAgent(
             objective=self.specified_task_prompt,
-            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
-            or "assistant",
+            role_name=self.assistant_sys_msg.role_name,
             output_language=output_language,
             message_window_size=message_window_size,
             **(task_creation_agent_kwargs or {}),
@@ -239,9 +238,7 @@ class BabyAGI:
 
         task_name = self.subtasks.popleft()
         assistant_msg_msg = BaseMessage.make_user_message(
-            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
-            or "assistant",
-            content=f"{task_name}",
+            role_name=self.assistant_sys_msg.role_name, content=f"{task_name}"
         )
 
         assistant_response = self.assistant_agent.step(assistant_msg_msg)

camel/societies/role_playing.py

@@ -149,8 +149,8 @@ class RolePlaying:
 
         self.assistant_agent: ChatAgent
         self.user_agent: ChatAgent
-        self.assistant_sys_msg: Optional[BaseMessage]
-        self.user_sys_msg: Optional[BaseMessage]
+        self.assistant_sys_msg: BaseMessage
+        self.user_sys_msg: BaseMessage
         self._init_agents(
             init_assistant_sys_msg,
             init_user_sys_msg,
@@ -454,11 +454,9 @@ class RolePlaying:
         )
         if init_msg_content is None:
             init_msg_content = default_init_msg_content
-
         # Initialize a message sent by the assistant
         init_msg = BaseMessage.make_assistant_message(
-            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
-            or "assistant",
+            role_name=self.assistant_sys_msg.role_name,
             content=init_msg_content,
         )
 

camel/storages/graph_storages/graph_element.py

@@ -13,12 +13,14 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Union
+from typing import List, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 
-if TYPE_CHECKING:
+try:
     from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
 
 
 class Node(BaseModel):
@@ -71,6 +73,6 @@ class GraphElement(BaseModel):
     source: Element
 
     def __post_init__(self):
-        if "Element" not in globals():
+        if Element is None:
             raise ImportError("""The 'unstructured' package is required to use
                               the 'source' attribute.""")

camel/storages/key_value_storages/json.py

@@ -18,12 +18,7 @@ from pathlib import Path
 from typing import Any, ClassVar, Dict, List, Optional
 
 from camel.storages.key_value_storages import BaseKeyValueStorage
-from camel.types import (
-    ModelType,
-    OpenAIBackendRole,
-    RoleType,
-    TaskType,
-)
+from camel.types import ModelType, OpenAIBackendRole, RoleType, TaskType
 
 
 class _CamelJSONEncoder(json.JSONEncoder):

camel/toolkits/__init__.py

@@ -12,37 +12,29 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 # ruff: noqa: I001
-from .function_tool import (
-    FunctionTool,
+from .openai_function import (
     OpenAIFunction,
     get_openai_function_schema,
     get_openai_tool_schema,
 )
 from .open_api_specs.security_config import openapi_security_config
 
-
+from .google_maps_toolkit import GoogleMapsToolkit
 from .math_toolkit import MathToolkit, MATH_FUNCS
+from .open_api_toolkit import OpenAPIToolkit
+from .retrieval_toolkit import RetrievalToolkit
 from .search_toolkit import SearchToolkit, SEARCH_FUNCS
+from .twitter_toolkit import TwitterToolkit
 from .weather_toolkit import WeatherToolkit, WEATHER_FUNCS
+from .slack_toolkit import SlackToolkit
 from .dalle_toolkit import DalleToolkit, DALLE_FUNCS
-from .ask_news_toolkit import AskNewsToolkit, AsyncAskNewsToolkit
-
 from .linkedin_toolkit import LinkedInToolkit
 from .reddit_toolkit import RedditToolkit
-from .base import BaseToolkit
-from .google_maps_toolkit import GoogleMapsToolkit
+
 from .code_execution import CodeExecutionToolkit
 from .github_toolkit import GithubToolkit
-from .google_scholar_toolkit import GoogleScholarToolkit
-from .arxiv_toolkit import ArxivToolkit
-from .slack_toolkit import SlackToolkit
-from .twitter_toolkit import TwitterToolkit, TWITTER_FUNCS
-from .open_api_toolkit import OpenAPIToolkit
-from .retrieval_toolkit import RetrievalToolkit
 
 __all__ = [
-    'BaseToolkit',
-    'FunctionTool',
     'OpenAIFunction',
     'get_openai_function_schema',
     'get_openai_tool_schema',
@@ -60,13 +52,8 @@ __all__ = [
     'LinkedInToolkit',
     'RedditToolkit',
     'CodeExecutionToolkit',
-    'AskNewsToolkit',
-    'AsyncAskNewsToolkit',
-    'GoogleScholarToolkit',
-    'ArxivToolkit',
     'MATH_FUNCS',
     'SEARCH_FUNCS',
     'WEATHER_FUNCS',
     'DALLE_FUNCS',
-    'TWITTER_FUNCS',
 ]

camel/toolkits/base.py

@@ -14,10 +14,11 @@
 
 from typing import List
 
-from camel.toolkits import FunctionTool
 from camel.utils import AgentOpsMeta
 
+from .openai_function import OpenAIFunction
+
 
 class BaseToolkit(metaclass=AgentOpsMeta):
-    def get_tools(self) -> List[FunctionTool]:
+    def get_tools(self) -> List[OpenAIFunction]:
         raise NotImplementedError("Subclasses must implement this method.")

camel/toolkits/code_execution.py

@@ -14,8 +14,9 @@
 from typing import List, Literal
 
 from camel.interpreters import InternalPythonInterpreter
-from camel.toolkits import FunctionTool
-from camel.toolkits.base import BaseToolkit
+from camel.toolkits import OpenAIFunction
+
+from .base import BaseToolkit
 
 
 class CodeExecutionToolkit(BaseToolkit):
@@ -57,12 +58,12 @@ class CodeExecutionToolkit(BaseToolkit):
             print(content)
         return content
 
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of FunctionTool objects representing the
+    def get_tools(self) -> List[OpenAIFunction]:
+        r"""Returns a list of OpenAIFunction objects representing the
         functions in the toolkit.
 
         Returns:
-            List[FunctionTool]: A list of FunctionTool objects
+            List[OpenAIFunction]: A list of OpenAIFunction objects
                 representing the functions in the toolkit.
         """
-        return [FunctionTool(self.execute_code)]
+        return [OpenAIFunction(self.execute_code)]

camel/toolkits/dalle_toolkit.py

@@ -20,7 +20,7 @@ from typing import List, Optional
 from openai import OpenAI
 from PIL import Image
 
-from camel.toolkits import FunctionTool
+from camel.toolkits import OpenAIFunction
 from camel.toolkits.base import BaseToolkit
 
 
@@ -132,15 +132,15 @@ class DalleToolkit(BaseToolkit):
 
         return image_path
 
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of FunctionTool objects representing the
+    def get_tools(self) -> List[OpenAIFunction]:
+        r"""Returns a list of OpenAIFunction objects representing the
         functions in the toolkit.
 
         Returns:
-            List[FunctionTool]: A list of FunctionTool objects
+            List[OpenAIFunction]: A list of OpenAIFunction objects
                 representing the functions in the toolkit.
         """
-        return [FunctionTool(self.get_dalle_img)]
+        return [OpenAIFunction(self.get_dalle_img)]
 
 
-DALLE_FUNCS: List[FunctionTool] = DalleToolkit().get_tools()
+DALLE_FUNCS: List[OpenAIFunction] = DalleToolkit().get_tools()

camel/toolkits/github_toolkit.py

@@ -18,10 +18,11 @@ from typing import List, Optional
 
 from pydantic import BaseModel
 
-from camel.toolkits import FunctionTool
-from camel.toolkits.base import BaseToolkit
 from camel.utils import dependencies_required
 
+from .base import BaseToolkit
+from .openai_function import OpenAIFunction
+
 
 class GithubIssue(BaseModel):
     r"""Represents a GitHub issue.
@@ -130,19 +131,19 @@ class GithubToolkit(BaseToolkit):
         self.github = Github(auth=Auth.Token(access_token))
         self.repo = self.github.get_repo(repo_name)
 
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of FunctionTool objects representing the
+    def get_tools(self) -> List[OpenAIFunction]:
+        r"""Returns a list of OpenAIFunction objects representing the
         functions in the toolkit.
 
         Returns:
-            List[FunctionTool]: A list of FunctionTool objects
+            List[OpenAIFunction]: A list of OpenAIFunction objects
                 representing the functions in the toolkit.
         """
         return [
-            FunctionTool(self.retrieve_issue_list),
-            FunctionTool(self.retrieve_issue),
-            FunctionTool(self.create_pull_request),
-            FunctionTool(self.retrieve_pull_requests),
+            OpenAIFunction(self.retrieve_issue_list),
+            OpenAIFunction(self.retrieve_issue),
+            OpenAIFunction(self.create_pull_request),
+            OpenAIFunction(self.retrieve_pull_requests),
         ]
 
     def get_github_access_token(self) -> str:

camel/toolkits/google_maps_toolkit.py

@@ -16,7 +16,7 @@ from functools import wraps
 from typing import Any, Callable, List, Optional, Union
 
 from camel.toolkits.base import BaseToolkit
-from camel.toolkits.function_tool import FunctionTool
+from camel.toolkits.openai_function import OpenAIFunction
 from camel.utils import dependencies_required
 
 
@@ -287,16 +287,16 @@ class GoogleMapsToolkit(BaseToolkit):
 
         return description
 
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of FunctionTool objects representing the
+    def get_tools(self) -> List[OpenAIFunction]:
+        r"""Returns a list of OpenAIFunction objects representing the
         functions in the toolkit.
 
         Returns:
-            List[FunctionTool]: A list of FunctionTool objects
+            List[OpenAIFunction]: A list of OpenAIFunction objects
                 representing the functions in the toolkit.
         """
         return [
-            FunctionTool(self.get_address_description),
-            FunctionTool(self.get_elevation),
-            FunctionTool(self.get_timezone),
+            OpenAIFunction(self.get_address_description),
+            OpenAIFunction(self.get_elevation),
+            OpenAIFunction(self.get_timezone),
         ]