camel-ai 0.2.3a1__py3-none-any.whl → 0.2.4__py3-none-any.whl

camel/utils/commons.py

@@ -257,18 +257,18 @@ def api_keys_required(*required_keys: str) -> Callable[[F], F]:
 
     def decorator(func: F) -> F:
         @wraps(func)
-        def wrapper(self, *args: Any, **kwargs: Any) -> Any:
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
             missing_environment_keys = [
                 k for k in required_keys if k not in os.environ
             ]
             if (
-                not getattr(self, '_api_key', None)
+                not (args and getattr(args[0], '_api_key', None))
                 and missing_environment_keys
             ):
                 raise ValueError(
                     f"Missing API keys: {', '.join(missing_environment_keys)}"
                 )
-            return func(self, *args, **kwargs)
+            return func(*args, **kwargs)
 
         return cast(F, wrapper)
 
@@ -577,3 +577,32 @@ def handle_http_error(response: requests.Response) -> str:
         return "Too Many Requests. You have hit the rate limit."
     else:
         return "HTTP Error"
+
+
+def retry_request(
+    func: Callable, retries: int = 3, delay: int = 1, *args: Any, **kwargs: Any
+) -> Any:
+    r"""Retries a function in case of any errors.
+
+    Args:
+        func (Callable): The function to be retried.
+        retries (int): Number of retry attempts. (default: :obj:`3`)
+        delay (int): Delay between retries in seconds. (default: :obj:`1`)
+        *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:
+        Exception: If all retry attempts fail.
+    """
+    for attempt in range(retries):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            print(f"Attempt {attempt + 1}/{retries} failed: {e}")
+            if attempt < retries - 1:
+                time.sleep(delay)
+            else:
+                raise

camel/utils/token_counting.py

@@ -20,10 +20,15 @@ from io import BytesIO
 from math import ceil
 from typing import TYPE_CHECKING, List, Optional
 
-from anthropic import Anthropic
 from PIL import Image
 
-from camel.types import ModelType, OpenAIImageType, OpenAIVisionDetailType
+from camel.types import (
+    ModelType,
+    OpenAIImageType,
+    OpenAIVisionDetailType,
+    UnifiedModelType,
+)
+from camel.utils import dependencies_required
 
 if TYPE_CHECKING:
     from mistral_common.protocol.instruct.request import (  # type:ignore[import-not-found]
@@ -40,145 +45,6 @@ SQUARE_TOKENS = 170
 EXTRA_TOKENS = 85
 
 
-def messages_to_prompt(messages: List[OpenAIMessage], model: ModelType) -> str:
-    r"""Parse the message list into a single prompt following model-specific
-    formats.
-
-    Args:
-        messages (List[OpenAIMessage]): Message list with the chat history
-            in OpenAI API format.
-        model (ModelType): Model type for which messages will be parsed.
-
-    Returns:
-        str: A single prompt summarizing all the messages.
-    """
-    system_message = messages[0]["content"]
-
-    ret: str
-    if model in [
-        ModelType.LLAMA_2,
-        ModelType.LLAMA_3,
-        ModelType.GROQ_LLAMA_3_8B,
-        ModelType.GROQ_LLAMA_3_70B,
-    ]:
-        # reference: https://github.com/facebookresearch/llama/blob/cfc3fc8c1968d390eb830e65c63865e980873a06/llama/generation.py#L212
-        seps = [" ", " </s><s>"]
-        role_map = {"user": "[INST]", "assistant": "[/INST]"}
-
-        system_prompt = f"[INST] <<SYS>>\n{system_message}\n<</SYS>>\n\n"
-        ret = ""
-        for i, msg in enumerate(messages[1:]):
-            role = role_map[msg["role"]]
-            content = msg["content"]
-            if content:
-                if not isinstance(content, str):
-                    raise ValueError(
-                        "Currently multimodal context is not "
-                        "supported by the token counter."
-                    )
-                if i == 0:
-                    ret += system_prompt + content
-                else:
-                    ret += role + " " + content + seps[i % 2]
-            else:
-                ret += role
-        return ret
-    elif model in [ModelType.VICUNA, ModelType.VICUNA_16K]:
-        seps = [" ", "</s>"]
-        role_map = {"user": "USER", "assistant": "ASSISTANT"}
-
-        system_prompt = f"{system_message}"
-        ret = system_prompt + seps[0]
-        for i, msg in enumerate(messages[1:]):
-            role = role_map[msg["role"]]
-            content = msg["content"]
-            if not isinstance(content, str):
-                raise ValueError(
-                    "Currently multimodal context is not "
-                    "supported by the token counter."
-                )
-            if content:
-                ret += role + ": " + content + seps[i % 2]
-            else:
-                ret += role + ":"
-        return ret
-    elif model == ModelType.GLM_4_OPEN_SOURCE:
-        system_prompt = f"[gMASK]<sop><|system|>\n{system_message}"
-        ret = system_prompt
-        for msg in messages[1:]:
-            role = msg["role"]
-            content = msg["content"]
-            if not isinstance(content, str):
-                raise ValueError(
-                    "Currently multimodal context is not "
-                    "supported by the token counter."
-                )
-            if content:
-                ret += "<|" + role + "|>" + "\n" + content
-            else:
-                ret += "<|" + role + "|>" + "\n"
-        return ret
-    elif model == ModelType.QWEN_2:
-        system_prompt = f"<|im_start|>system\n{system_message}<|im_end|>"
-        ret = system_prompt + "\n"
-        for msg in messages[1:]:
-            role = msg["role"]
-            content = msg["content"]
-            if not isinstance(content, str):
-                raise ValueError(
-                    "Currently multimodal context is not "
-                    "supported by the token counter."
-                )
-            if content:
-                ret += (
-                    '<|im_start|>'
-                    + role
-                    + '\n'
-                    + content
-                    + '<|im_end|>'
-                    + '\n'
-                )
-            else:
-                ret += '<|im_start|>' + role + '\n'
-        return ret
-    elif model == ModelType.GROQ_MIXTRAL_8_7B:
-        # Mistral/Mixtral format
-        system_prompt = f"<s>[INST] {system_message} [/INST]\n"
-        ret = system_prompt
-
-        for msg in messages[1:]:
-            if msg["role"] == "user":
-                ret += f"[INST] {msg['content']} [/INST]\n"
-            elif msg["role"] == "assistant":
-                ret += f"{msg['content']}</s>\n"
-
-            if not isinstance(msg['content'], str):
-                raise ValueError(
-                    "Currently multimodal context is not "
-                    "supported by the token counter."
-                )
-
-        return ret.strip()
-    elif model in [ModelType.GROQ_GEMMA_7B_IT, ModelType.GROQ_GEMMA_2_9B_IT]:
-        # Gemma format
-        ret = f"<bos>{system_message}\n"
-        for msg in messages:
-            if msg["role"] == "user":
-                ret += f"Human: {msg['content']}\n"
-            elif msg["role"] == "assistant":
-                ret += f"Assistant: {msg['content']}\n"
-
-            if not isinstance(msg['content'], str):
-                raise ValueError(
-                    "Currently multimodal context is not supported by the token counter."
-                )
-
-        ret += "<eos>"
-        return ret
-    else:
-        raise ValueError(f"Invalid model type: {model}")
-
-
 def get_model_encoding(value_for_tiktoken: str):
     r"""Get model encoding from tiktoken.
 
@@ -221,67 +87,15 @@ class BaseTokenCounter(ABC):
         pass
 
 
-class OpenSourceTokenCounter(BaseTokenCounter):
-    def __init__(self, model_type: ModelType, model_path: str):
-        r"""Constructor for the token counter for open-source models.
-
-        Args:
-            model_type (ModelType): Model type for which tokens will be
-                counted.
-            model_path (str): The path to the model files, where the tokenizer
-                model should be located.
-        """
-
-        # Use a fast Rust-based tokenizer if it is supported for a given model.
-        # If a fast tokenizer is not available for a given model,
-        # a normal Python-based tokenizer is returned instead.
-        from transformers import AutoTokenizer
-
-        try:
-            tokenizer = AutoTokenizer.from_pretrained(
-                model_path,
-                use_fast=True,
-            )
-        except TypeError:
-            tokenizer = AutoTokenizer.from_pretrained(
-                model_path,
-                use_fast=False,
-            )
-        except Exception:
-            raise ValueError(
-                f"Invalid `model_path` ({model_path}) is provided. "
-                "Tokenizer loading failed."
-            )
-
-        self.tokenizer = tokenizer
-        self.model_type = model_type
-
-    def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
-        r"""Count number of tokens in the provided message list using
-        loaded tokenizer specific for this type of model.
-
-        Args:
-            messages (List[OpenAIMessage]): Message list with the chat history
-                in OpenAI API format.
-
-        Returns:
-            int: Number of tokens in the messages.
-        """
-        prompt = messages_to_prompt(messages, self.model_type)
-        input_ids = self.tokenizer(prompt).input_ids
-
-        return len(input_ids)
-
-
 class OpenAITokenCounter(BaseTokenCounter):
-    def __init__(self, model: ModelType):
+    def __init__(self, model: UnifiedModelType):
         r"""Constructor for the token counter for OpenAI models.
 
         Args:
-            model (ModelType): Model type for which tokens will be counted.
+            model (UnifiedModelType): Model type for which tokens will be
+                counted.
         """
         self.model: str = model.value_for_tiktoken
-        self.model_type = model
 
         self.tokens_per_message: int
         self.tokens_per_name: int
@@ -404,15 +218,11 @@ class OpenAITokenCounter(BaseTokenCounter):
 
 
 class AnthropicTokenCounter(BaseTokenCounter):
-    def __init__(self, model_type: ModelType):
-        r"""Constructor for the token counter for Anthropic models.
+    @dependencies_required('anthropic')
+    def __init__(self):
+        r"""Constructor for the token counter for Anthropic models."""
+        from anthropic import Anthropic
 
-        Args:
-            model_type (ModelType): Model type for which tokens will be
-                counted.
-        """
-
-        self.model_type = model_type
         self.client = Anthropic()
         self.tokenizer = self.client.get_tokenizer()
 
@@ -435,12 +245,16 @@ class AnthropicTokenCounter(BaseTokenCounter):
 
 
 class GeminiTokenCounter(BaseTokenCounter):
-    def __init__(self, model_type: ModelType):
-        r"""Constructor for the token counter for Gemini models."""
+    def __init__(self, model_type: UnifiedModelType):
+        r"""Constructor for the token counter for Gemini models.
+
+        Args:
+            model_type (UnifiedModelType): Model type for which tokens will be
+                counted.
+        """
         import google.generativeai as genai
 
-        self.model_type = model_type
-        self._client = genai.GenerativeModel(self.model_type.value)
+        self._client = genai.GenerativeModel(model_type)
 
     def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
         r"""Count number of tokens in the provided message list using
@@ -468,12 +282,13 @@ class GeminiTokenCounter(BaseTokenCounter):
         return self._client.count_tokens(converted_messages).total_tokens
 
 
-class LiteLLMTokenCounter:
-    def __init__(self, model_type: str):
+class LiteLLMTokenCounter(BaseTokenCounter):
+    def __init__(self, model_type: UnifiedModelType):
         r"""Constructor for the token counter for LiteLLM models.
 
         Args:
-            model_type (str): Model type for which tokens will be counted.
+            model_type (UnifiedModelType): Model type for which tokens will be
+                counted.
         """
         self.model_type = model_type
         self._token_counter = None
@@ -538,7 +353,10 @@ class MistralTokenCounter(BaseTokenCounter):
         model_name = (
             "codestral-22b"
             if self.model_type
-            in {ModelType.MISTRAL_CODESTRAL, ModelType.MISTRAL_CODESTRAL_MAMBA}
+            in {
+                ModelType.MISTRAL_CODESTRAL,
+                ModelType.MISTRAL_CODESTRAL_MAMBA,
+            }
             else self.model_type.value
         )
 

camel/workforce/role_playing_worker.py

@@ -172,7 +172,7 @@ class RolePlayingWorker(Worker):
             role_name="User",
             content=prompt,
         )
-        response = self.summarize_agent.step(req, output_schema=TaskResult)
+        response = self.summarize_agent.step(req, response_format=TaskResult)
         result_dict = ast.literal_eval(response.msg.content)
         task_result = TaskResult(**result_dict)
         task.result = task_result.content

camel/workforce/single_agent_worker.py

@@ -77,7 +77,7 @@ class SingleAgentWorker(Worker):
             content=prompt,
         )
         try:
-            response = self.worker.step(req, output_schema=TaskResult)
+            response = self.worker.step(req, response_format=TaskResult)
         except Exception as e:
             print(
                 f"{Fore.RED}Error occurred while processing task {task.id}:"

camel/workforce/task_channel.py

@@ -21,12 +21,13 @@ from camel.tasks import Task
 class PacketStatus(Enum):
     r"""The status of a packet. The packet can be in one of the following
     states:
+
     - ``SENT``: The packet has been sent to a worker.
     - ``RETURNED``: The packet has been returned by the worker, meaning that
-            the status of the task inside has been updated.
+      the status of the task inside has been updated.
     - ``ARCHIVED``: The packet has been archived, meaning that the content of
-            the task inside will not be changed. The task is considered
-            as a dependency.
+      the task inside will not be changed. The task is considered
+      as a dependency.
     """
 
     SENT = "SENT"

camel/workforce/workforce.py

@@ -287,7 +287,7 @@ class Workforce(BaseNode):
         )
 
         response = self.coordinator_agent.step(
-            req, output_schema=TaskAssignResult
+            req, response_format=TaskAssignResult
         )
         result_dict = ast.literal_eval(response.msg.content)
         task_assign_result = TaskAssignResult(**result_dict)
@@ -319,7 +319,7 @@ class Workforce(BaseNode):
             role_name="User",
             content=prompt,
         )
-        response = self.coordinator_agent.step(req, output_schema=WorkerConf)
+        response = self.coordinator_agent.step(req, response_format=WorkerConf)
         result_dict = ast.literal_eval(response.msg.content)
         new_node_conf = WorkerConf(**result_dict)
 
@@ -364,8 +364,8 @@ class Workforce(BaseNode):
         ).as_dict()
 
         model = ModelFactory.create(
-            model_platform=ModelPlatformType.OPENAI,
-            model_type=ModelType.GPT_4O,
+            model_platform=ModelPlatformType.DEFAULT,
+            model_type=ModelType.DEFAULT,
             model_config_dict=model_config_dict,
         )
 

camel_ai-0.2.4.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 @ CAMEL-AI.org
+
+   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.