camel-ai 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

camel/models/openai_audio_models.py

@@ -0,0 +1,251 @@
+# =========== 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 Any, List, Optional, Union
+
+from openai import OpenAI, _legacy_response
+
+from camel.types import AudioModelType, VoiceType
+
+
+class OpenAIAudioModels:
+    r"""Provides access to OpenAI's Text-to-Speech (TTS) and Speech_to_Text
+    (STT) models."""
+
+    def __init__(
+        self,
+    ) -> None:
+        r"""Initialize an instance of OpenAI."""
+        url = os.environ.get('OPENAI_API_BASE_URL')
+        self._client = OpenAI(timeout=120, max_retries=3, base_url=url)
+
+    def text_to_speech(
+        self,
+        input: str,
+        model_type: AudioModelType = AudioModelType.TTS_1,
+        voice: VoiceType = VoiceType.ALLOY,
+        storage_path: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Union[
+        List[_legacy_response.HttpxBinaryResponseContent],
+        _legacy_response.HttpxBinaryResponseContent,
+    ]:
+        r"""Convert text to speech using OpenAI's TTS model. This method
+        converts the given input text to speech using the specified model and
+        voice.
+
+        Args:
+            input (str): The text to be converted to speech.
+            model_type (AudioModelType, optional): The TTS model to use.
+                Defaults to `AudioModelType.TTS_1`.
+            voice (VoiceType, optional): The voice to be used for generating
+                speech. Defaults to `VoiceType.ALLOY`.
+            storage_path (str, optional): The local path to store the
+                generated speech file if provided, defaults to `None`.
+            **kwargs (Any): Extra kwargs passed to the TTS API.
+
+        Returns:
+            Union[List[_legacy_response.HttpxBinaryResponseContent],
+                _legacy_response.HttpxBinaryResponseContent]: List of response
+                content object from OpenAI if input charaters more than 4096,
+                single response content if input charaters less than 4096.
+
+        Raises:
+            Exception: If there's an error during the TTS API call.
+        """
+        try:
+            # Model only support at most 4096 characters one time.
+            max_chunk_size = 4095
+            audio_chunks = []
+            chunk_index = 0
+            if len(input) > max_chunk_size:
+                while input:
+                    if len(input) <= max_chunk_size:
+                        chunk = input
+                        input = ''
+                    else:
+                        # Find the nearest period before the chunk size limit
+                        while input[max_chunk_size - 1] != '.':
+                            max_chunk_size -= 1
+
+                        chunk = input[:max_chunk_size]
+                        input = input[max_chunk_size:].lstrip()
+
+                    response = self._client.audio.speech.create(
+                        model=model_type.value,
+                        voice=voice.value,
+                        input=chunk,
+                        **kwargs,
+                    )
+                    if storage_path:
+                        try:
+                            # Create a new storage path for each chunk
+                            file_name, file_extension = os.path.splitext(
+                                storage_path
+                            )
+                            new_storage_path = (
+                                f"{file_name}_{chunk_index}{file_extension}"
+                            )
+                            response.write_to_file(new_storage_path)
+                            chunk_index += 1
+                        except Exception as e:
+                            raise Exception(
+                                "Error during writing the file"
+                            ) from e
+
+                    audio_chunks.append(response)
+                return audio_chunks
+
+            else:
+                response = self._client.audio.speech.create(
+                    model=model_type.value,
+                    voice=voice.value,
+                    input=input,
+                    **kwargs,
+                )
+
+            if storage_path:
+                try:
+                    response.write_to_file(storage_path)
+                except Exception as e:
+                    raise Exception("Error during write the file") from e
+
+            return response
+
+        except Exception as e:
+            raise Exception("Error during TTS API call") from e
+
+    def _split_audio(
+        self, audio_file_path: str, chunk_size_mb: int = 24
+    ) -> list:
+        r"""Split the audio file into smaller chunks. Since the Whisper API
+        only supports files that are less than 25 MB.
+
+        Args:
+            audio_file_path (str): Path to the input audio file.
+            chunk_size_mb (int, optional): Size of each chunk in megabytes.
+                Defaults to `24`.
+
+        Returns:
+            list: List of paths to the split audio files.
+        """
+        from pydub import AudioSegment
+
+        audio = AudioSegment.from_file(audio_file_path)
+        audio_format = os.path.splitext(audio_file_path)[1][1:].lower()
+
+        # Calculate chunk size in bytes
+        chunk_size_bytes = chunk_size_mb * 1024 * 1024
+
+        # Number of chunks needed
+        num_chunks = os.path.getsize(audio_file_path) // chunk_size_bytes + 1
+
+        # Create a directory to store the chunks
+        output_dir = os.path.splitext(audio_file_path)[0] + "_chunks"
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Get audio chunk len in milliseconds
+        chunk_size_milliseconds = len(audio) // (num_chunks)
+
+        # Split the audio into chunks
+        split_files = []
+        for i in range(num_chunks):
+            start = i * chunk_size_milliseconds
+            end = (i + 1) * chunk_size_milliseconds
+            if i + 1 == num_chunks:
+                chunk = audio[start:]
+            else:
+                chunk = audio[start:end]
+            # Create new chunk path
+            chunk_path = os.path.join(output_dir, f"chunk_{i}.{audio_format}")
+            chunk.export(chunk_path, format=audio_format)
+            split_files.append(chunk_path)
+        return split_files
+
+    def speech_to_text(
+        self,
+        audio_file_path: str,
+        translate_into_english: bool = False,
+        **kwargs: Any,
+    ) -> str:
+        r"""Convert speech audio to text.
+
+        Args:
+            audio_file_path (str): The audio file path, supporting one of
+                these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or
+                webm.
+            translate_into_english (bool, optional): Whether to translate the
+                speech into English. Defaults to `False`.
+            **kwargs (Any): Extra keyword arguments passed to the
+                Speech-to-Text (STT) API.
+
+        Returns:
+            str: The output text.
+
+        Raises:
+            ValueError: If the audio file format is not supported.
+            Exception: If there's an error during the STT API call.
+        """
+        supported_formats = [
+            "flac",
+            "mp3",
+            "mp4",
+            "mpeg",
+            "mpga",
+            "m4a",
+            "ogg",
+            "wav",
+            "webm",
+        ]
+        file_format = audio_file_path.split(".")[-1].lower()
+
+        if file_format not in supported_formats:
+            raise ValueError(f"Unsupported audio file format: {file_format}")
+        try:
+            if os.path.getsize(audio_file_path) > 24 * 1024 * 1024:
+                # Split audio into chunks
+                audio_chunks = self._split_audio(audio_file_path)
+                texts = []
+                for chunk_path in audio_chunks:
+                    audio_data = open(chunk_path, "rb")
+                    if translate_into_english:
+                        translation = self._client.audio.translations.create(
+                            model="whisper-1", file=audio_data, **kwargs
+                        )
+                        texts.append(translation.text)
+                    else:
+                        transcription = (
+                            self._client.audio.transcriptions.create(
+                                model="whisper-1", file=audio_data, **kwargs
+                            )
+                        )
+                        texts.append(transcription.text)
+                    os.remove(chunk_path)  # Delete temporary chunk file
+                return " ".join(texts)
+            else:
+                # Process the entire audio file
+                audio_data = open(audio_file_path, "rb")
+
+                if translate_into_english:
+                    translation = self._client.audio.translations.create(
+                        model="whisper-1", file=audio_data, **kwargs
+                    )
+                    return translation.text
+                else:
+                    transcription = self._client.audio.transcriptions.create(
+                        model="whisper-1", file=audio_data, **kwargs
+                    )
+                    return transcription.text
+        except Exception as e:
+            raise Exception("Error during STT API call") from e

camel/models/openai_model.py

@@ -16,22 +16,22 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import OPENAI_API_PARAMS_WITH_FUNCTIONS
+from camel.configs import OPENAI_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
-from camel.utils import (
-    BaseTokenCounter,
-    OpenAITokenCounter,
-    openai_api_key_required,
-)
+from camel.utils import BaseTokenCounter, OpenAITokenCounter, api_key_required
 
 
 class OpenAIModel(BaseModelBackend):
     r"""OpenAI API in a unified BaseModelBackend interface."""
 
-    def __init__(self, model_type: ModelType,
-                 model_config_dict: Dict[str, Any]) -> None:
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+    ) -> None:
         r"""Constructor for OpenAI backend.
 
         Args:
@@ -39,10 +39,15 @@ class OpenAIModel(BaseModelBackend):
                 one of GPT_* 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
+                OpenAI service. (default: :obj:`None`)
         """
         super().__init__(model_type, model_config_dict)
         url = os.environ.get('OPENAI_API_BASE_URL', None)
-        self._client = OpenAI(timeout=60, max_retries=3, base_url=url)
+        self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        self._client = OpenAI(
+            timeout=60, max_retries=3, base_url=url, api_key=self._api_key
+        )
         self._token_counter: Optional[BaseTokenCounter] = None
 
     @property
@@ -57,7 +62,7 @@ class OpenAIModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(self.model_type)
         return self._token_counter
 
-    @openai_api_key_required
+    @api_key_required
     def run(
         self,
         messages: List[OpenAIMessage],
@@ -89,9 +94,11 @@ class OpenAIModel(BaseModelBackend):
                 unexpected arguments to OpenAI API.
         """
         for param in self.model_config_dict:
-            if param not in OPENAI_API_PARAMS_WITH_FUNCTIONS:
-                raise ValueError(f"Unexpected argument `{param}` is "
-                                 "input into OpenAI model backend.")
+            if param not in OPENAI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into OpenAI model backend."
+                )
 
     @property
     def stream(self) -> bool:

camel/models/stub_model.py

@@ -30,7 +30,6 @@ from camel.utils import BaseTokenCounter
 
 
 class StubTokenCounter(BaseTokenCounter):
-
     def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
         r"""Token counting for STUB models, directly returning a constant.
 
@@ -47,13 +46,19 @@ class StubTokenCounter(BaseTokenCounter):
 
 class StubModel(BaseModelBackend):
     r"""A dummy model used for unit tests."""
+
     model_type = ModelType.STUB
 
-    def __init__(self, model_type: ModelType,
-                 model_config_dict: Dict[str, Any]) -> None:
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+    ) -> None:
         r"""All arguments are unused for the dummy model."""
         super().__init__(model_type, model_config_dict)
         self._token_counter: Optional[BaseTokenCounter] = None
+        self._api_key = api_key
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -90,6 +95,7 @@ class StubModel(BaseModelBackend):
                         content=ARBITRARY_STRING,
                         role="assistant",
                     ),
+                    logprobs=None,
                 )
             ],
             usage=CompletionUsage(
@@ -101,6 +107,5 @@ class StubModel(BaseModelBackend):
         return response
 
     def check_model_config(self):
-        r"""Directly pass the check on arguments to STUB model.
-        """
+        r"""Directly pass the check on arguments to STUB model."""
         pass

camel/prompts/__init__.py

@@ -11,16 +11,17 @@
 # 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 TextPrompt, CodePrompt, TextPromptDict
 from .ai_society import AISocietyPromptTemplateDict
+from .base import CodePrompt, TextPrompt, TextPromptDict
 from .code import CodePromptTemplateDict
-from .misalignment import MisalignmentPromptTemplateDict
-from .translation import TranslationPromptTemplateDict
-from .solution_extraction import SolutionExtractionPromptTemplateDict
 from .evaluation import EvaluationPromptTemplateDict
+from .misalignment import MisalignmentPromptTemplateDict
+from .object_recognition import ObjectRecognitionPromptTemplateDict
+from .prompt_templates import PromptTemplateGenerator
 from .role_description_prompt_template import RoleDescriptionPromptTemplateDict
+from .solution_extraction import SolutionExtractionPromptTemplateDict
 from .task_prompt_template import TaskPromptTemplateDict
-from .prompt_templates import PromptTemplateGenerator
+from .translation import TranslationPromptTemplateDict
 
 __all__ = [
     'TextPrompt',
@@ -35,4 +36,5 @@ __all__ = [
     'TaskPromptTemplateDict',
     'PromptTemplateGenerator',
     'SolutionExtractionPromptTemplateDict',
+    'ObjectRecognitionPromptTemplateDict',
 ]

camel/prompts/ai_society.py

@@ -13,7 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from typing import Any
 
-from camel.prompts import TextPrompt, TextPromptDict
+from camel.prompts.base import TextPrompt, TextPromptDict
 from camel.types import RoleType
 
 
@@ -38,19 +38,23 @@ class AISocietyPromptTemplateDict(TextPromptDict):
             outlines the rules of the conversation and provides instructions
             for giving instructions to the AI assistant.
     """
+
     GENERATE_ASSISTANTS = TextPrompt(
         """You are a helpful assistant that can play many different roles.
 Now please list {num_roles} different roles that you can play with your expertise in diverse fields.
-Sort them by alphabetical order. No explanation required.""")
+Sort them by alphabetical order. No explanation required."""
+    )
 
     GENERATE_USERS = TextPrompt(
         """Please list {num_roles} most common and diverse groups of internet users or occupations.
 Use singular form. No explanation.
-Sort them by alphabetical order. No explanation required.""")
+Sort them by alphabetical order. No explanation required."""
+    )
 
     GENERATE_TASKS = TextPrompt(
         """List {num_tasks} diverse tasks that {assistant_role} can assist {user_role} cooperatively to achieve together.
-Be concise. Be creative.""")
+Be concise. Be creative."""
+    )
 
     TASK_SPECIFY_PROMPT = TextPrompt(
         """Here is a task that {assistant_role} will help {user_role} to complete: {task}.
@@ -106,16 +110,19 @@ Never say <CAMEL_TASK_DONE> unless my responses have solved your task.""")
         """You are a {critic_role} who teams up with a {user_role} and a {assistant_role} to solve a task: {task}.
 Your job is to select an option from their proposals and provides your explanations.
 Your selection criteria are {criteria}.
-You always have to choose an option from the proposals.""")
+You always have to choose an option from the proposals."""
+    )
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        self.update({
-            "generate_assistants": self.GENERATE_ASSISTANTS,
-            "generate_users": self.GENERATE_USERS,
-            "generate_tasks": self.GENERATE_TASKS,
-            "task_specify_prompt": self.TASK_SPECIFY_PROMPT,
-            RoleType.ASSISTANT: self.ASSISTANT_PROMPT,
-            RoleType.USER: self.USER_PROMPT,
-            RoleType.CRITIC: self.CRITIC_PROMPT,
-        })
+        self.update(
+            {
+                "generate_assistants": self.GENERATE_ASSISTANTS,
+                "generate_users": self.GENERATE_USERS,
+                "generate_tasks": self.GENERATE_TASKS,
+                "task_specify_prompt": self.TASK_SPECIFY_PROMPT,
+                RoleType.ASSISTANT: self.ASSISTANT_PROMPT,
+                RoleType.USER: self.USER_PROMPT,
+                RoleType.CRITIC: self.CRITIC_PROMPT,
+            }
+        )

camel/prompts/base.py

@@ -12,20 +12,11 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import inspect
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    TypeVar,
-    Union,
-)
+from typing import Any, Callable, Dict, Optional, Set, TypeVar, Union
 
+from camel.interpreters import BaseInterpreter, SubprocessInterpreter
 from camel.types import RoleType
-from camel.utils import PythonInterpreter
+from camel.utils import get_system_information
 
 T = TypeVar('T')
 
@@ -63,8 +54,11 @@ def return_prompt_wrapper(
             return cls(result)
         elif isinstance(result, tuple):
             new_result = tuple(
-                cls(item) if isinstance(item, str)
-                and not isinstance(item, cls) else item for item in result)
+                cls(item)
+                if isinstance(item, str) and not isinstance(item, cls)
+                else item
+                for item in result
+            )
             return new_result
         return result
 
@@ -107,9 +101,9 @@ class TextPrompt(str):
 
     @property
     def key_words(self) -> Set[str]:
-        r"""Returns a set of strings representing the keywords in the prompt.
-        """
+        r"""Returns a set of strings representing the keywords in the prompt."""
         from camel.utils import get_prompt_template_key_words
+
         return get_prompt_template_key_words(self)
 
     def format(self, *args: Any, **kwargs: Any) -> 'TextPrompt':
@@ -172,55 +166,68 @@ class CodePrompt(TextPrompt):
         self._code_type = code_type
 
     def execute(
-        self, interpreter: Optional[PythonInterpreter] = None,
-        user_variable: Optional[Dict[str, Any]] = None
-    ) -> Tuple[Any, PythonInterpreter]:
-        r"""Executes the code string by a given python interpreter.
+        self,
+        interpreter: Optional[BaseInterpreter] = None,
+        **kwargs: Any,
+    ) -> str:
+        r"""Executes the code string using the provided interpreter.
+
+        This method runs a code string through either a specified interpreter
+        or a default one. It supports additional keyword arguments for
+        flexibility.
 
         Args:
-            interpreter (PythonInterpreter, optional): interpreter to be used
-                during code execution. (default: :obj:`None`)
-            user_variable (Optional[Dict[str, Any]]): varibales that can be
-                used in the code, which applying fuzzy matching, such as images
-                or documents. (default: :obj:`None`)
+            interpreter (Optional[BaseInterpreter]): The interpreter instance
+                to use for execution. If `None`, a default interpreter is used.
+                (default: :obj:`None`)
+            **kwargs: Additional keyword arguments passed to the interpreter to
+                run the code.
 
         Returns:
-            Tuple[Any, PythonInterpreter]: A tuple containing the execution
-                result and the used interpreter. The execution result
-                represents the value of the last statement (excluding "import")
-                in the code. This value could potentially be the desired result
-                of the LLM-generated code.        
-    """
-        # NOTE: Only supports Python code for now.
-        if not interpreter:
-            interpreter = PythonInterpreter(action_space=globals())
-        execution_res = interpreter.execute(self, fuzz_state=user_variable,
-                                            keep_state=True)
-        return execution_res, interpreter
+            str: The result of the code execution. If the execution fails, this
+                should include sufficient information to diagnose and correct
+                the issue.
+
+        Raises:
+            InterpreterError: If the code execution encounters errors that
+                could be resolved by modifying or regenerating the code.
+        """
+        if interpreter is None:
+            execution_res = SubprocessInterpreter().run(
+                self, self._code_type, **kwargs
+            )
+        else:
+            execution_res = interpreter.run(self, self._code_type, **kwargs)
+        return execution_res
 
 
 # flake8: noqa :E501
 class TextPromptDict(Dict[Any, TextPrompt]):
-    r"""A dictionary class that maps from key to :obj:`TextPrompt` object.
-    """
+    r"""A dictionary class that maps from key to :obj:`TextPrompt` object."""
+
     EMBODIMENT_PROMPT = TextPrompt(
-        """You are the physical embodiment of the {role} who is working on solving a task: {task}.
+        "System information :"
+        + "\n".join(
+            f"{key}: {value}" for key, value in get_system_information().items()
+        )
+        + "\n"
+        + """You are the physical embodiment of the {role} who is working on solving a task: {task}.
 You can do things in the physical world including browsing the Internet, reading documents, drawing images, creating videos, executing code and so on.
 Your job is to perform the physical actions necessary to interact with the physical world.
 You will receive thoughts from the {role} and you will need to perform the actions described in the thoughts.
-You can write a series of simple commands in Python to act.
-You can perform a set of actions by calling the available Python functions.
+You can write a series of simple commands in to act.
+You can perform a set of actions by calling the available functions.
 You should perform actions based on the descriptions of the functions.
 
-Here is your action space:
+Here is your action space but it is not limited:
 {action_space}
 
-You should only perform actions in the action space.
 You can perform multiple actions.
 You can perform actions in any order.
-First, explain the actions you will perform and your reasons, then write Python code to implement your actions.
-If you decide to perform actions, you must write Python code to implement the actions.
-You may print intermediate results if necessary.""")
+First, explain the actions you will perform and your reasons, then write code to implement your actions.
+If you decide to perform actions, you must write code to implement the actions.
+You may print intermediate results if necessary."""
+    )
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)