camel-ai 0.1.1__py3-none-any.whl

camel/storages/key_value_storages/json.py

@@ -0,0 +1,97 @@
+# =========== 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
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from camel.storages.key_value_storages import BaseKeyValueStorage
+from camel.types import (
+    ModelType,
+    OpenAIBackendRole,
+    RoleType,
+    TaskType,
+    VectorDistance,
+)
+
+
+class _CamelJSONEncoder(json.JSONEncoder):
+    r"""A custom JSON encoder for serializing specifically enumerated types.
+    Ensures enumerated types can be stored in and retrieved from JSON format.
+    """
+    CAMEL_ENUMS = {
+        "RoleType": RoleType,
+        "TaskType": TaskType,
+        "ModelType": ModelType,
+        "OpenAIBackendRole": OpenAIBackendRole,
+        "VectorDistance": VectorDistance,
+    }
+
+    def default(self, obj) -> Any:
+        if type(obj) in self.CAMEL_ENUMS.values():
+            return {"__enum__": str(obj)}
+        # Let the base class default method raise the TypeError
+        return json.JSONEncoder.default(self, obj)
+
+
+class JsonStorage(BaseKeyValueStorage):
+    r"""A concrete implementation of the :obj:`BaseKeyValueStorage` using JSON
+    files. Allows for persistent storage of records in a human-readable format.
+
+    Args:
+        path (Path, optional): Path to the desired JSON file. If `None`, a
+            default path `./chat_history.json` will be used.
+            (default: :obj:`None`)
+    """
+
+    def __init__(self, path: Optional[Path] = None) -> None:
+        self.json_path = path or Path("./chat_history.json")
+        self.json_path.touch()
+
+    def _json_object_hook(self, d) -> Any:
+        if "__enum__" in d:
+            name, member = d["__enum__"].split(".")
+            return getattr(_CamelJSONEncoder.CAMEL_ENUMS[name], member)
+        else:
+            return d
+
+    def save(self, records: List[Dict[str, Any]]) -> None:
+        r"""Saves a batch of records to the key-value storage system.
+
+        Args:
+            records (List[Dict[str, Any]]): A list of dictionaries, where each
+                dictionary represents a unique record to be stored.
+        """
+        with self.json_path.open("a") as f:
+            f.writelines(
+                [json.dumps(r, cls=_CamelJSONEncoder) + "\n" for r in records])
+
+    def load(self) -> List[Dict[str, Any]]:
+        r"""Loads all stored records from the key-value storage system.
+
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries, where each dictionary
+                represents a stored record.
+        """
+        with self.json_path.open("r") as f:
+            return [
+                json.loads(r, object_hook=self._json_object_hook)
+                for r in f.readlines()
+            ]
+
+    def clear(self) -> None:
+        r"""Removes all records from the key-value storage system.
+        """
+        with self.json_path.open("w"):
+            pass

camel/terminators/__init__.py

@@ -0,0 +1,23 @@
+# =========== 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. ===========
+from .base import BaseTerminator
+from .response_terminator import ResponseWordsTerminator, ResponseTerminator
+from .token_limit_terminator import TokenLimitTerminator
+
+__all__ = [
+    'BaseTerminator',
+    'ResponseTerminator',
+    'ResponseWordsTerminator',
+    'TokenLimitTerminator',
+]

camel/terminators/base.py

@@ -0,0 +1,44 @@
+# =========== 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. ===========
+from abc import ABC, abstractmethod
+from typing import List, Optional, Tuple
+
+from camel.messages import BaseMessage
+
+
+class BaseTerminator(ABC):
+
+    def __init__(self, *args, **kwargs) -> None:
+        self._terminated: bool = False
+        self._termination_reason: Optional[str] = None
+
+    @abstractmethod
+    def is_terminated(self, *args, **kwargs) -> Tuple[bool, Optional[str]]:
+        pass
+
+    @abstractmethod
+    def reset(self):
+        pass
+
+
+class ResponseTerminator(BaseTerminator):
+
+    @abstractmethod
+    def is_terminated(
+            self, messages: List[BaseMessage]) -> Tuple[bool, Optional[str]]:
+        pass
+
+    @abstractmethod
+    def reset(self):
+        pass

camel/terminators/response_terminator.py

@@ -0,0 +1,118 @@
+# =========== 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. ===========
+from collections import defaultdict
+from typing import Dict, List, Optional, Tuple
+
+from camel.messages import BaseMessage
+from camel.types import TerminationMode
+
+from .base import ResponseTerminator
+
+
+class ResponseWordsTerminator(ResponseTerminator):
+    r"""Terminate agent when some words reached to occurrence
+    limit by any message of the response.
+
+    Args:
+        words_dict (dict): Dictionary of words and its occurrence
+            threshold.
+        case_sensitive (bool): Whether count the words as
+            case-sensitive. (default: :obj:`False`)
+        mode (TerminationMode): Whether terminate agent if any
+            or all pre-set words reached the threshold.
+            (default: :obj:`TerminationMode.ANY`)
+    """
+
+    def __init__(self, words_dict: Dict[str,
+                                        int], case_sensitive: bool = False,
+                 mode: TerminationMode = TerminationMode.ANY):
+        super().__init__()
+        self.words_dict = words_dict
+        self.case_sensitive = case_sensitive
+        self.mode = mode
+        self._word_count_dict: List[Dict[str, int]] = []
+        self._validate()
+
+    def _validate(self):
+        if len(self.words_dict) == 0:
+            raise ValueError("`words_dict` cannot be empty")
+        for word in self.words_dict:
+            threshold = self.words_dict[word]
+            if threshold <= 0:
+                raise ValueError(f"Threshold for word `{word}` should "
+                                 f"be larger than 0, got `{threshold}`")
+
+    def is_terminated(
+            self, messages: List[BaseMessage]) -> Tuple[bool, Optional[str]]:
+        r"""Whether terminate the agent by checking the occurrence
+        of specified words reached to preset thresholds.
+
+        Args:
+            messages (list): List of :obj:`BaseMessage` from a response.
+
+        Returns:
+            tuple: A tuple containing whether the agent should be
+                terminated and a string of termination reason.
+        """
+        if self._terminated:
+            return True, self._termination_reason
+
+        for i in range(len(messages)):
+            if i >= len(self._word_count_dict):
+                self._word_count_dict.append(defaultdict(int))
+
+        for word in self.words_dict:
+            special_word = word if self.case_sensitive else word.lower()
+            for i, message in enumerate(messages):
+                if self.case_sensitive:
+                    content = message.content
+                else:
+                    content = message.content.lower()
+                if special_word in content:
+                    self._word_count_dict[i][word] += 1
+
+        num_reached: List[int] = []
+        all_reasons: List[List[str]] = []
+        for i in range(len(self._word_count_dict)):
+            reached = 0
+            reasons: List[str] = []
+            for word, value in self._word_count_dict[i].items():
+                if value >= self.words_dict[word]:
+                    reached += 1
+                    reason = (f"Word `{word}` appears {value} times in the "
+                              f"{i + 1} message of the response which has "
+                              f"reached termination threshold "
+                              f"{self.words_dict[word]}.")
+                    reasons.append(reason)
+            all_reasons.append(reasons)
+            num_reached.append(reached)
+
+        for i, reached in enumerate(num_reached):
+            if self.mode == TerminationMode.ANY:
+                if reached > 0:
+                    self._terminated = True
+                    self._termination_reason = "\n".join(all_reasons[i])
+            elif self.mode == TerminationMode.ALL:
+                if reached >= len(self.words_dict):
+                    self._terminated = True
+                    self._termination_reason = "\n".join(all_reasons[i])
+            else:
+                raise ValueError(f"Unsupported termination mode "
+                                 f"`{self.mode}`")
+        return self._terminated, self._termination_reason
+
+    def reset(self):
+        self._terminated = False
+        self._termination_reason = None
+        self._word_count_dict = defaultdict(int)

camel/terminators/token_limit_terminator.py

@@ -0,0 +1,55 @@
+# =========== 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. ===========
+from typing import Optional, Tuple
+
+from camel.terminators import BaseTerminator
+
+
+class TokenLimitTerminator(BaseTerminator):
+    r"""Terminate agent if number of tokens reached to token limit threshold.
+
+    Args:
+        token_limit (int): Token limit threshold.
+    """
+
+    def __init__(self, token_limit: int):
+        super().__init__()
+        self.token_limit = token_limit
+
+    def _validate(self):
+        if self.token_limit <= 0:
+            raise ValueError(f"`token_limit` should be a "
+                             f"value larger than 0, got {self.token_limit}.")
+
+    def is_terminated(self, num_tokens: int) -> Tuple[bool, Optional[str]]:
+        r"""Whether terminate the agent by checking number of
+        used tokens reached to token limit.
+
+        Args:
+            num_tokens (int): Number of tokens.
+
+        Returns:
+            tuple: A tuple containing whether the agent should be
+                terminated and a string of termination reason.
+        """
+        if self._terminated:
+            return True, self._termination_reason
+        if num_tokens >= self.token_limit:
+            self._terminated = True
+            self._termination_reason = "max_tokens_exceeded"
+        return self._terminated, self._termination_reason
+
+    def reset(self):
+        self._terminated = False
+        self._termination_reason = None

camel/types/__init__.py

@@ -0,0 +1,54 @@
+# =========== 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. ===========
+from .enums import (
+    RoleType,
+    ModelType,
+    TaskType,
+    TerminationMode,
+    OpenAIBackendRole,
+    EmbeddingModelType,
+    VectorDistance,
+)
+from .openai_types import (
+    Choice,
+    ChatCompletion,
+    ChatCompletionChunk,
+    ChatCompletionMessage,
+    ChatCompletionMessageParam,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionUserMessageParam,
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionFunctionMessageParam,
+    CompletionUsage,
+)
+
+__all__ = [
+    'RoleType',
+    'ModelType',
+    'TaskType',
+    'TerminationMode',
+    'OpenAIBackendRole',
+    'EmbeddingModelType',
+    'VectorDistance',
+    'Choice',
+    'ChatCompletion',
+    'ChatCompletionChunk',
+    'ChatCompletionMessage',
+    'ChatCompletionMessageParam',
+    'ChatCompletionSystemMessageParam',
+    'ChatCompletionUserMessageParam',
+    'ChatCompletionAssistantMessageParam',
+    'ChatCompletionFunctionMessageParam',
+    'CompletionUsage',
+]

camel/types/enums.py

@@ -0,0 +1,176 @@
+# =========== 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 re
+from enum import Enum
+
+
+class RoleType(Enum):
+    ASSISTANT = "assistant"
+    USER = "user"
+    CRITIC = "critic"
+    EMBODIMENT = "embodiment"
+    DEFAULT = "default"
+
+
+class ModelType(Enum):
+    GPT_3_5_TURBO = "gpt-3.5-turbo-1106"
+    GPT_3_5_TURBO_16K = "gpt-3.5-turbo-1106"
+    GPT_4 = "gpt-4"
+    GPT_4_32K = "gpt-4-32k"
+    GPT_4_TURBO = "gpt-4-1106-preview"
+    GPT_4_TURBO_VISION = "gpt-4-vision-preview"
+
+    STUB = "stub"
+
+    LLAMA_2 = "llama-2"
+    VICUNA = "vicuna"
+    VICUNA_16K = "vicuna-16k"
+
+    @property
+    def value_for_tiktoken(self) -> str:
+        return self.value if self is not ModelType.STUB else "gpt-3.5-turbo"
+
+    @property
+    def is_openai(self) -> bool:
+        r"""Returns whether this type of models is an OpenAI-released model."""
+        return self in {
+            ModelType.GPT_3_5_TURBO,
+            ModelType.GPT_3_5_TURBO_16K,
+            ModelType.GPT_4,
+            ModelType.GPT_4_32K,
+            ModelType.GPT_4_TURBO,
+            ModelType.GPT_4_TURBO_VISION,
+        }
+
+    @property
+    def is_open_source(self) -> bool:
+        r"""Returns whether this type of models is open-source."""
+        return self in {
+            ModelType.LLAMA_2,
+            ModelType.VICUNA,
+            ModelType.VICUNA_16K,
+        }
+
+    @property
+    def token_limit(self) -> int:
+        r"""Returns the maximum token limit for a given model.
+        Returns:
+            int: The maximum token limit for the given model.
+        """
+        if self is ModelType.GPT_3_5_TURBO:
+            return 16385
+        elif self is ModelType.GPT_3_5_TURBO_16K:
+            return 16385
+        elif self is ModelType.GPT_4:
+            return 8192
+        elif self is ModelType.GPT_4_32K:
+            return 32768
+        elif self is ModelType.GPT_4_TURBO:
+            return 128000
+        elif self is ModelType.GPT_4_TURBO_VISION:
+            return 128000
+        elif self is ModelType.STUB:
+            return 4096
+        elif self is ModelType.LLAMA_2:
+            return 4096
+        elif self is ModelType.VICUNA:
+            # reference: https://lmsys.org/blog/2023-03-30-vicuna/
+            return 2048
+        elif self is ModelType.VICUNA_16K:
+            return 16384
+        else:
+            raise ValueError("Unknown model type")
+
+    def validate_model_name(self, model_name: str) -> bool:
+        r"""Checks whether the model type and the model name matches.
+
+        Args:
+            model_name (str): The name of the model, e.g. "vicuna-7b-v1.5".
+        Returns:
+            bool: Whether the model type mathches the model name.
+        """
+        if self is ModelType.VICUNA:
+            pattern = r'^vicuna-\d+b-v\d+\.\d+$'
+            return bool(re.match(pattern, model_name))
+        elif self is ModelType.VICUNA_16K:
+            pattern = r'^vicuna-\d+b-v\d+\.\d+-16k$'
+            return bool(re.match(pattern, model_name))
+        elif self is ModelType.LLAMA_2:
+            return (self.value in model_name.lower()
+                    or "llama2" in model_name.lower())
+        else:
+            return self.value in model_name.lower()
+
+
+class EmbeddingModelType(Enum):
+    ADA_2 = "text-embedding-ada-002"
+    ADA_1 = "text-embedding-ada-001"
+    BABBAGE_1 = "text-embedding-babbage-001"
+    CURIE_1 = "text-embedding-curie-001"
+    DAVINCI_1 = "text-embedding-davinci-001"
+
+    @property
+    def is_openai(self) -> bool:
+        r"""Returns whether this type of models is an OpenAI-released model."""
+        return self in {
+            EmbeddingModelType.ADA_2,
+            EmbeddingModelType.ADA_1,
+            EmbeddingModelType.BABBAGE_1,
+            EmbeddingModelType.CURIE_1,
+            EmbeddingModelType.DAVINCI_1,
+        }
+
+    @property
+    def output_dim(self) -> int:
+        if self is EmbeddingModelType.ADA_2:
+            return 1536
+        elif self is EmbeddingModelType.ADA_1:
+            return 1024
+        elif self is EmbeddingModelType.BABBAGE_1:
+            return 2048
+        elif self is EmbeddingModelType.CURIE_1:
+            return 4096
+        elif self is EmbeddingModelType.DAVINCI_1:
+            return 12288
+        else:
+            raise ValueError(f"Unknown model type {self}.")
+
+
+class TaskType(Enum):
+    AI_SOCIETY = "ai_society"
+    CODE = "code"
+    MISALIGNMENT = "misalignment"
+    TRANSLATION = "translation"
+    EVALUATION = "evaluation"
+    SOLUTION_EXTRACTION = "solution_extraction"
+    ROLE_DESCRIPTION = "role_description"
+    DEFAULT = "default"
+
+
+class VectorDistance(Enum):
+    DOT = 1
+    COSINE = 2
+    EUCLIDEAN = 3
+
+
+class OpenAIBackendRole(Enum):
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    USER = "user"
+    FUNCTION = "function"
+
+
+class TerminationMode(Enum):
+    ANY = "any"
+    ALL = "all"

camel/types/openai_types.py

@@ -0,0 +1,39 @@
+# =========== 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. ===========
+# isort: skip_file
+from openai.types.chat.chat_completion import ChatCompletion, Choice
+from openai.types.chat.chat_completion_assistant_message_param import (
+    ChatCompletionAssistantMessageParam, )
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+from openai.types.chat.chat_completion_function_message_param import (
+    ChatCompletionFunctionMessageParam, )
+from openai.types.chat.chat_completion_message import ChatCompletionMessage
+from openai.types.chat.chat_completion_message_param import (
+    ChatCompletionMessageParam, )
+from openai.types.chat.chat_completion_system_message_param import (
+    ChatCompletionSystemMessageParam, )
+from openai.types.chat.chat_completion_user_message_param import (
+    ChatCompletionUserMessageParam, )
+from openai.types.completion_usage import CompletionUsage
+
+Choice = Choice
+ChatCompletion = ChatCompletion
+ChatCompletionChunk = ChatCompletionChunk
+ChatCompletionMessage = ChatCompletionMessage
+ChatCompletionMessageParam = ChatCompletionMessageParam
+ChatCompletionSystemMessageParam = ChatCompletionSystemMessageParam
+ChatCompletionUserMessageParam = ChatCompletionUserMessageParam
+ChatCompletionAssistantMessageParam = ChatCompletionAssistantMessageParam
+ChatCompletionFunctionMessageParam = ChatCompletionFunctionMessageParam
+CompletionUsage = CompletionUsage

camel/utils/__init__.py

@@ -0,0 +1,47 @@
+# =========== 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. ===========
+from .python_interpreter import PythonInterpreter
+from .commons import (
+    openai_api_key_required,
+    print_text_animated,
+    get_prompt_template_key_words,
+    get_first_int,
+    download_tasks,
+    parse_doc,
+    get_task_list,
+    check_server_running,
+)
+from .token_counting import (
+    get_model_encoding,
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    OpenSourceTokenCounter,
+)
+
+__all__ = [
+    'count_tokens_openai_chat_models',
+    'openai_api_key_required',
+    'print_text_animated',
+    'get_prompt_template_key_words',
+    'get_first_int',
+    'download_tasks',
+    'PythonInterpreter',
+    'parse_doc',
+    'get_task_list',
+    'get_model_encoding',
+    'check_server_running',
+    'BaseTokenCounter',
+    'OpenAITokenCounter',
+    'OpenSourceTokenCounter',
+]