camel-ai 0.2.20a0__py3-none-any.whl → 0.2.21__py3-none-any.whl

camel/interpreters/subprocess_interpreter.py

@@ -98,15 +98,70 @@ class SubprocessInterpreter(BaseInterpreter):
         if not file.is_file():
             raise RuntimeError(f"{file} is not a file.")
         code_type = self._check_code_type(code_type)
-        cmd = shlex.split(
-            self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
-                file_name=str(file)
+        if code_type == "python":
+            # For Python code, use ast to analyze and modify the code
+            import ast
+
+            import astor
+
+            with open(file, 'r') as f:
+                source = f.read()
+
+            # Parse the source code
+            try:
+                tree = ast.parse(source)
+                # Get the last node
+                if tree.body:
+                    last_node = tree.body[-1]
+                    # If it's an expression, wrap it in a print
+                    if isinstance(last_node, ast.Expr):
+                        tree.body[-1] = ast.Expr(
+                            value=ast.Call(
+                                func=ast.Name(id='print', ctx=ast.Load()),
+                                args=[
+                                    ast.Call(
+                                        func=ast.Name(
+                                            id='repr', ctx=ast.Load()
+                                        ),
+                                        args=[last_node.value],
+                                        keywords=[],
+                                    )
+                                ],
+                                keywords=[],
+                            )
+                        )
+                    # Fix missing source locations
+                    ast.fix_missing_locations(tree)
+                    # Convert back to source
+                    modified_source = astor.to_source(tree)
+                    # Create a temporary file with the modified source
+                    temp_file = self._create_temp_file(modified_source, "py")
+                    cmd = shlex.split(f"python {temp_file!s}")
+            except SyntaxError:
+                # If parsing fails, run the original file
+                cmd = shlex.split(
+                    self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
+                        file_name=str(file)
+                    )
+                )
+        else:
+            # For non-Python code, use standard execution
+            cmd = shlex.split(
+                self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
+                    file_name=str(file)
+                )
             )
-        )
+
         proc = subprocess.Popen(
             cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
         )
         stdout, stderr = proc.communicate()
+        return_code = proc.returncode
+
+        # Clean up temporary file if it was created
+        if code_type == "python" and 'temp_file' in locals():
+            temp_file.unlink()
+
         if self.print_stdout and stdout:
             print("======stdout======")
             print(Fore.GREEN + stdout + Fore.RESET)
@@ -115,8 +170,19 @@ class SubprocessInterpreter(BaseInterpreter):
             print("======stderr======")
             print(Fore.RED + stderr + Fore.RESET)
             print("==================")
-        exec_result = f"{stdout}"
-        exec_result += f"(stderr: {stderr})" if stderr else ""
+
+        # Build the execution result
+        exec_result = ""
+        if stdout:
+            exec_result += stdout
+        if stderr:
+            exec_result += f"(stderr: {stderr})"
+        if return_code != 0:
+            error_msg = f"(Execution failed with return code {return_code})"
+            if not stderr:
+                exec_result += error_msg
+            elif error_msg not in stderr:
+                exec_result += error_msg
         return exec_result
 
     def run(

camel/models/__init__.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from .aiml_model import AIMLModel
 from .anthropic_model import AnthropicModel
 from .azure_openai_model import AzureOpenAIModel
 from .base_model import BaseModelBackend
@@ -72,4 +73,5 @@ __all__ = [
     'FishAudioModel',
     'InternLMModel',
     'MoonshotModel',
+    'AIMLModel',
 ]

camel/models/aiml_model.py

@@ -0,0 +1,147 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import AIML_API_PARAMS, AIMLConfig
+from camel.messages import OpenAIMessage
+from camel.models.base_model import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class AIMLModel(BaseModelBackend):
+    r"""AIML API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into OpenAI client. If :obj:`None`,
+            :obj:`AIMLConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the AIML service. (default: :obj:`None`)
+        url (Optional[str], optional): The URL to the AIML service. If
+            not provided, :obj:`https://api.aimlapi.com/v1` will be used.
+            (default: :obj:`None`)
+        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`)
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", 'AIML_API_KEY'),
+        ]
+    )
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = AIMLConfig().as_dict()
+        api_key = api_key or os.environ.get("AIML_API_KEY")
+        url = url or os.environ.get(
+            "AIML_API_BASE_URL",
+            "https://api.aimlapi.com/v1",
+        )
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self._client = OpenAI(
+            timeout=180,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        # Process model configuration parameters
+        model_config = self.model_config_dict.copy()
+
+        # Handle special case for tools parameter
+        if model_config.get('tools') is None:
+            model_config['tools'] = []
+
+        response = self._client.chat.completions.create(
+            messages=messages, model=self.model_type, **model_config
+        )
+        return response
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to AIML API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to AIML API.
+        """
+        for param in self.model_config_dict:
+            if param not in AIML_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into AIML model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        """Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/model_factory.py

@@ -13,6 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from typing import Dict, Optional, Type, Union
 
+from camel.models.aiml_model import AIMLModel
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.azure_openai_model import AzureOpenAIModel
 from camel.models.base_model import BaseModelBackend
@@ -104,6 +105,8 @@ class ModelFactory:
             model_class = NvidiaModel
         elif model_platform.is_siliconflow:
             model_class = SiliconFlowModel
+        elif model_platform.is_aiml:
+            model_class = AIMLModel
 
         elif model_platform.is_openai and model_type.is_openai:
             model_class = OpenAIModel

camel/models/siliconflow_model.py

@@ -18,7 +18,7 @@ from openai import OpenAI, Stream
 
 from camel.configs import SILICONFLOW_API_PARAMS, SiliconFlowConfig
 from camel.messages import OpenAIMessage
-from camel.models import BaseModelBackend
+from camel.models.base_model import BaseModelBackend
 from camel.types import (
     ChatCompletion,
     ChatCompletionChunk,

camel/societies/workforce/role_playing_worker.py

@@ -168,11 +168,9 @@ class RolePlayingWorker(Worker):
             chat_history=chat_history_str,
             additional_info=task.additional_info,
         )
-        req = BaseMessage.make_user_message(
-            role_name="User",
-            content=prompt,
+        response = self.summarize_agent.step(
+            prompt, response_format=TaskResult
         )
-        response = self.summarize_agent.step(req, response_format=TaskResult)
         result_dict = json.loads(response.msg.content)
         task_result = TaskResult(**result_dict)
         task.result = task_result.content

camel/societies/workforce/single_agent_worker.py

@@ -19,7 +19,6 @@ from typing import Any, List
 from colorama import Fore
 
 from camel.agents import ChatAgent
-from camel.messages.base import BaseMessage
 from camel.societies.workforce.prompts import PROCESS_TASK_PROMPT
 from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
@@ -72,12 +71,8 @@ class SingleAgentWorker(Worker):
             dependency_tasks_info=dependency_tasks_info,
             additional_info=task.additional_info,
         )
-        req = BaseMessage.make_user_message(
-            role_name="User",
-            content=prompt,
-        )
         try:
-            response = self.worker.step(req, response_format=TaskResult)
+            response = self.worker.step(prompt, response_format=TaskResult)
         except Exception as e:
             print(
                 f"{Fore.RED}Error occurred while processing task {task.id}:"

camel/societies/workforce/workforce.py

@@ -281,13 +281,9 @@ class Workforce(BaseNode):
             child_nodes_info=self._get_child_nodes_info(),
             additional_info=task.additional_info,
         )
-        req = BaseMessage.make_user_message(
-            role_name="User",
-            content=prompt,
-        )
 
         response = self.coordinator_agent.step(
-            req, response_format=TaskAssignResult
+            prompt, response_format=TaskAssignResult
         )
         result_dict = json.loads(response.msg.content)
         task_assign_result = TaskAssignResult(**result_dict)
@@ -315,11 +311,9 @@ class Workforce(BaseNode):
             child_nodes_info=self._get_child_nodes_info(),
             additional_info=task.additional_info,
         )
-        req = BaseMessage.make_user_message(
-            role_name="User",
-            content=prompt,
+        response = self.coordinator_agent.step(
+            prompt, response_format=WorkerConf
         )
-        response = self.coordinator_agent.step(req, response_format=WorkerConf)
         result_dict = json.loads(response.msg.content)
         new_node_conf = WorkerConf(**result_dict)
 

camel/toolkits/__init__.py

@@ -45,6 +45,7 @@ from .human_toolkit import HumanToolkit
 from .stripe_toolkit import StripeToolkit
 from .video_toolkit import VideoDownloaderToolkit
 from .dappier_toolkit import DappierToolkit
+from .sympy_toolkit import SymPyToolkit
 from .semantic_scholar_toolkit import SemanticScholarToolkit
 
 __all__ = [
@@ -78,5 +79,6 @@ __all__ = [
     'MeshyToolkit',
     'OpenBBToolkit',
     'DappierToolkit',
+    'SymPyToolkit',
     'SemanticScholarToolkit',
 ]

camel/toolkits/reddit_toolkit.py

@@ -16,10 +16,9 @@ import os
 import time
 from typing import Any, Dict, List, Union
 
-from requests.exceptions import RequestException
-
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
+from camel.utils import retry_on_error
 
 
 class RedditToolkit(BaseToolkit):
@@ -61,30 +60,7 @@ class RedditToolkit(BaseToolkit):
             request_timeout=30,  # Set a timeout to handle delays
         )
 
-    def _retry_request(self, func, *args, **kwargs):
-        r"""Retries a function in case of network-related errors.
-
-        Args:
-            func (callable): The function to be retried.
-            *args: Arguments to pass to the function.
-            **kwargs: Keyword arguments to pass to the function.
-
-        Returns:
-            Any: The result of the function call if successful.
-
-        Raises:
-            RequestException: If all retry attempts fail.
-        """
-        for attempt in range(self.retries):
-            try:
-                return func(*args, **kwargs)
-            except RequestException as e:
-                print(f"Attempt {attempt + 1}/{self.retries} failed: {e}")
-                if attempt < self.retries - 1:
-                    time.sleep(self.delay)
-                else:
-                    raise
-
+    @retry_on_error()
     def collect_top_posts(
         self,
         subreddit_name: str,
@@ -113,8 +89,8 @@ class RedditToolkit(BaseToolkit):
                 "Please set the environment variables."
             )
 
-        subreddit = self._retry_request(self.reddit.subreddit, subreddit_name)
-        top_posts = self._retry_request(subreddit.top, limit=post_limit)
+        subreddit = self.reddit.subreddit(subreddit_name)
+        top_posts = subreddit.top(limit=post_limit)
         data = []
 
         for post in top_posts:
@@ -122,9 +98,7 @@ class RedditToolkit(BaseToolkit):
                 "Post Title": post.title,
                 "Comments": [
                     {"Comment Body": comment.body, "Upvotes": comment.score}
-                    for comment in self._retry_request(
-                        lambda post=post: list(post.comments)
-                    )[:comment_limit]
+                    for comment in list(post.comments)[:comment_limit]
                 ],
             }
             data.append(post_data)
@@ -192,15 +166,11 @@ class RedditToolkit(BaseToolkit):
         data = []
 
         for subreddit_name in subreddits:
-            subreddit = self._retry_request(
-                self.reddit.subreddit, subreddit_name
-            )
-            top_posts = self._retry_request(subreddit.top, limit=post_limit)
+            subreddit = self.reddit.subreddit(subreddit_name)
+            top_posts = subreddit.top(limit=post_limit)
 
             for post in top_posts:
-                for comment in self._retry_request(
-                    lambda post=post: list(post.comments)
-                )[:comment_limit]:
+                for comment in list(post.comments)[:comment_limit]:
                     # Print comment body for debugging
                     if any(
                         keyword.lower() in comment.body.lower()