camel-ai 0.2.25__py3-none-any.whl → 0.2.26__py3-none-any.whl

camel/extractors/python_strategies.py

@@ -0,0 +1,226 @@
+# ========= 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 ast
+from typing import Optional
+
+from camel.extractors.base import BaseExtractorStrategy
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class BoxedStrategy(BaseExtractorStrategy):
+    r"""Extracts content from \\boxed{} environments."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract content from \\boxed{} environments.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Content inside \\boxed{} if found, else None.
+        """
+        # Find the start of the boxed content
+        boxed_pattern = "\\boxed{"
+        if boxed_pattern not in text:
+            logger.debug("No \\boxed{} content found in the response")
+            return None
+
+        start_idx = text.find(boxed_pattern) + len(boxed_pattern)
+        if start_idx >= len(text):
+            logger.debug("Malformed \\boxed{} (no content after opening)")
+            return None
+
+        # Use stack-based approach to handle nested braces
+        stack = 1  # Start with one opening brace
+        end_idx = start_idx
+        escape_mode = False
+
+        for i in range(start_idx, len(text)):
+            char = text[i]
+
+            # Handle escape sequences
+            if escape_mode:
+                escape_mode = False
+                continue
+
+            if char == '\\':
+                escape_mode = True
+                continue
+
+            if char == '{':
+                stack += 1
+            elif char == '}':
+                stack -= 1
+
+            if stack == 0:  # Found the matching closing brace
+                end_idx = i
+                break
+
+        # Check if we found a complete boxed expression
+        if stack != 0:
+            logger.debug("Unbalanced braces in \\boxed{} content")
+            return None
+
+        # Extract the content
+        content = text[start_idx:end_idx].strip()
+        logger.debug(f"Extracted boxed content: {content}")
+        return content
+
+
+class PythonListStrategy(BaseExtractorStrategy):
+    r"""Extracts and normalizes Python lists."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract and normalize a Python list.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Normalized list as a string if found, else None.
+        """
+
+        text = text.strip()
+        if not (text.startswith('[') and text.endswith(']')):
+            logger.debug("Content is not a list format (missing brackets)")
+            return None
+
+        try:
+            # Fix any escaped quotes before parsing
+            fixed_content = text.replace('\\"', '"')
+            parsed = ast.literal_eval(fixed_content)
+            if isinstance(parsed, list):
+                # Sort the list for normalization
+                sorted_list = sorted(parsed, key=lambda x: str(x))
+                return repr(sorted_list)
+            else:
+                logger.debug(f"Content is not a list, got {type(parsed)}")
+                return None
+        except (SyntaxError, ValueError) as e:
+            logger.debug(f"Failed to parse as Python list: {e}")
+            return None
+
+
+class PythonDictStrategy(BaseExtractorStrategy):
+    r"""Extracts and normalizes Python dictionaries."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract and normalize a Python dictionary.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Normalized dictionary as a string, else None.
+        """
+
+        text = text.strip()
+        if not (text.startswith('{') and text.endswith('}')):
+            logger.debug("Content is not a dictionary format (missing braces)")
+            return None
+
+        try:
+            # Fix any escaped quotes before parsing
+            fixed_content = text.replace('\\"', '"')
+            parsed = ast.literal_eval(fixed_content)
+            if isinstance(parsed, dict):
+                # Sort the dictionary items for normalization
+                sorted_dict = dict(
+                    sorted(parsed.items(), key=lambda x: str(x[0]))
+                )
+                return repr(sorted_dict)
+            else:
+                logger.debug(
+                    f"Content is not a dictionary, got {type(parsed)}"
+                )
+                return None
+        except (SyntaxError, ValueError) as e:
+            logger.debug(f"Failed to parse as Python dictionary: {e}")
+            return None
+
+
+class PythonSetStrategy(BaseExtractorStrategy):
+    r"""Extracts and normalizes Python sets."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract and normalize a Python set.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Normalized set as a string if found, else None.
+        """
+
+        text = text.strip()
+        # Check for set syntax: {1, 2, 3} or set([1, 2, 3])
+        if not (
+            (text.startswith('{') and text.endswith('}'))
+            or (text.startswith('set(') and text.endswith(')'))
+        ):
+            logger.debug("Content is not a set format")
+            return None
+
+        try:
+            # Fix any escaped quotes before parsing
+            fixed_content = text.replace('\\"', '"')
+            parsed = ast.literal_eval(fixed_content)
+            if isinstance(parsed, set):
+                # Sort the set elements for normalization
+                sorted_set = sorted(parsed, key=lambda x: str(x))
+                return repr(set(sorted_set))
+            else:
+                logger.debug(f"Content is not a set, got {type(parsed)}")
+                return None
+        except (SyntaxError, ValueError) as e:
+            logger.debug(f"Failed to parse as Python set: {e}")
+            return None
+
+
+class PythonTupleStrategy(BaseExtractorStrategy):
+    r"""Extracts and normalizes Python tuples."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract and normalize a Python tuple.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Normalized tuple as a string if found, else None.
+        """
+
+        text = text.strip()
+        # Check for tuple syntax: (1, 2, 3) or (1,)
+        if not (text.startswith('(') and text.endswith(')')):
+            logger.debug("Content is not a tuple format (missing parentheses)")
+            return None
+
+        try:
+            # Fix any escaped quotes before parsing
+            fixed_content = text.replace('\\"', '"')
+            parsed = ast.literal_eval(fixed_content)
+            if isinstance(parsed, tuple):
+                # Sort the tuple elements for normalization
+                sorted_tuple = tuple(sorted(parsed, key=lambda x: str(x)))
+                return repr(sorted_tuple)
+            else:
+                logger.debug(f"Content is not a tuple, got {type(parsed)}")
+                return None
+        except (SyntaxError, ValueError) as e:
+            logger.debug(f"Failed to parse as Python tuple: {e}")
+            return None

camel/models/anthropic_model.py

@@ -35,13 +35,13 @@ class AnthropicModel(BaseModelBackend):
         model_type (Union[ModelType, str]): Model for which a backend is
             created, one of CLAUDE_* series.
         model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into Anthropic.messages.create().  If
+            that will be fed into `openai.ChatCompletion.create()`.  If
             :obj:`None`, :obj:`AnthropicConfig().as_dict()` will be used.
             (default: :obj:`None`)
         api_key (Optional[str], optional): The API key for authenticating with
             the Anthropic service. (default: :obj:`None`)
         url (Optional[str], optional): The url to the Anthropic service.
-            (default: :obj:`None`)
+            (default: :obj:`https://api.anthropic.com/v1/`)
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`AnthropicTokenCounter`
             will be used. (default: :obj:`None`)
@@ -61,43 +61,24 @@ class AnthropicModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        from anthropic import Anthropic, AsyncAnthropic
+        from openai import AsyncOpenAI, OpenAI
 
         if model_config_dict is None:
             model_config_dict = AnthropicConfig().as_dict()
         api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
-        url = url or os.environ.get("ANTHROPIC_API_BASE_URL")
+        url = (
+            url
+            or os.environ.get("ANTHROPIC_API_BASE_URL")
+            or "https://api.anthropic.com/v1/"
+        )
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self.client = Anthropic(api_key=self._api_key, base_url=self._url)
-        self.async_client = AsyncAnthropic(
-            api_key=self._api_key, base_url=self._url
-        )
+        self.client = OpenAI(base_url=self._url, api_key=self._api_key)
 
-    def _convert_response_from_anthropic_to_openai(self, response):
-        # openai ^1.0.0 format, reference openai/types/chat/chat_completion.py
-        obj = ChatCompletion.construct(
-            id=None,
-            choices=[
-                dict(
-                    index=0,
-                    message={
-                        "role": "assistant",
-                        "content": next(
-                            content.text
-                            for content in response.content
-                            if content.type == "text"
-                        ),
-                    },
-                    finish_reason=response.stop_reason,
-                )
-            ],
-            created=None,
-            model=response.model,
-            object="chat.completion",
+        self.async_client = AsyncOpenAI(
+            api_key=self._api_key, base_url=self._url
         )
-        return obj
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -126,22 +107,13 @@ class AnthropicModel(BaseModelBackend):
         Returns:
             ChatCompletion: Response in the OpenAI API format.
         """
-        from anthropic import NOT_GIVEN
-
-        if messages[0]["role"] == "system":
-            sys_msg = str(messages.pop(0)["content"])
-        else:
-            sys_msg = NOT_GIVEN  # type: ignore[assignment]
-        response = self.client.messages.create(
+        response = self.client.chat.completions.create(
             model=self.model_type,
-            system=sys_msg,
-            messages=messages,  # type: ignore[arg-type]
+            messages=messages,
             **self.model_config_dict,
+            tools=tools,  # type: ignore[arg-type]
         )
 
-        # format response to openai format
-        response = self._convert_response_from_anthropic_to_openai(response)
-
         return response
 
     async def _arun(
@@ -159,21 +131,14 @@ class AnthropicModel(BaseModelBackend):
         Returns:
             ChatCompletion: Response in the OpenAI API format.
         """
-        from anthropic import NOT_GIVEN
-
-        if messages[0]["role"] == "system":
-            sys_msg = str(messages.pop(0)["content"])
-        else:
-            sys_msg = NOT_GIVEN  # type: ignore[assignment]
-        response = await self.async_client.messages.create(
+        response = await self.async_client.chat.completions.create(
             model=self.model_type,
-            system=sys_msg,
-            messages=messages,  # type: ignore[arg-type]
+            messages=messages,
             **self.model_config_dict,
+            tools=tools,  # type: ignore[arg-type]
         )
 
-        # format response to openai format
-        return self._convert_response_from_anthropic_to_openai(response)
+        return response
 
     def check_model_config(self):
         r"""Check whether the model configuration is valid for anthropic
@@ -181,8 +146,7 @@ class AnthropicModel(BaseModelBackend):
 
         Raises:
             ValueError: If the model configuration dictionary contains any
-                unexpected arguments to OpenAI API, or it does not contain
-                :obj:`model_path` or :obj:`server_url`.
+                unexpected arguments to Anthropic API.
         """
         for param in self.model_config_dict:
             if param not in ANTHROPIC_API_PARAMS:

camel/storages/graph_storages/graph_element.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import List, Union
+from typing import List, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -45,6 +45,7 @@ class Relationship(BaseModel):
         subj (Node): The subject/source node of the relationship.
         obj (Node): The object/target node of the relationship.
         type (str):  The type of the relationship.
+        timestamp (str, optional): The timestamp of the relationship.
         properties (dict): Additional properties associated with the
             relationship.
     """
@@ -52,6 +53,7 @@ class Relationship(BaseModel):
     subj: Node
     obj: Node
     type: str = "Relationship"
+    timestamp: Optional[str] = None
     properties: dict = Field(default_factory=dict)
 
 

camel/storages/graph_storages/neo4j_graph.py

@@ -339,18 +339,24 @@ class Neo4jGraph(BaseGraphStorage):
             ]
         )
 
-    def add_triplet(self, subj: str, obj: str, rel: str) -> None:
-        r"""Adds a relationship (triplet) between two entities in the database.
+    def add_triplet(
+        self, subj: str, obj: str, rel: str, timestamp: Optional[str] = None
+    ) -> None:
+        r"""Adds a relationship (triplet) between two entities
+            in the database with a timestamp.
 
         Args:
             subj (str): The identifier for the subject entity.
             obj (str): The identifier for the object entity.
             rel (str): The relationship between the subject and object.
+            timestamp (Optional[str]): The timestamp of the relationship.
+                                Defaults to None.
         """
         query = """
             MERGE (n1:`%s` {id:$subj})
             MERGE (n2:`%s` {id:$obj})
-            MERGE (n1)-[:`%s`]->(n2)
+            MERGE (n1)-[r:`%s`]->(n2)
+            SET r.timestamp = $timestamp
         """
 
         prepared_statement = query % (
@@ -361,7 +367,10 @@ class Neo4jGraph(BaseGraphStorage):
 
         # Execute the query within a database session
         with self.driver.session(database=self.database) as session:
-            session.run(prepared_statement, {"subj": subj, "obj": obj})
+            session.run(
+                prepared_statement,
+                {"subj": subj, "obj": obj, "timestamp": timestamp},
+            )
 
     def _delete_rel(self, subj: str, obj: str, rel: str) -> None:
         r"""Deletes a specific relationship between two nodes in the Neo4j
@@ -721,3 +730,68 @@ class Neo4jGraph(BaseGraphStorage):
             return result[0] if result else {}
         except CypherSyntaxError as e:
             raise ValueError(f"Generated Cypher Statement is not valid\n{e}")
+
+    def get_triplet(
+        self,
+        subj: Optional[str] = None,
+        obj: Optional[str] = None,
+        rel: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        r"""
+        Query triplet information. If subj, obj, or rel is
+        not specified, returns all matching triplets.
+
+        Args:
+            subj (Optional[str]): The ID of the subject node.
+                        If None, matches any subject node.
+            obj (Optional[str]): The ID of the object node.
+                        If None, matches any object node.
+            rel (Optional[str]): The type of relationship.
+                        If None, matches any relationship type.
+
+        Returns:
+            List[Dict[str, Any]]: A list of matching triplets,
+                    each containing subj, obj, rel, and timestamp.
+        """
+        import logging
+
+        logging.basicConfig(level=logging.DEBUG)
+        logger = logging.getLogger(__name__)
+
+        # Construct the query
+        query = """
+                MATCH (n1:Entity)-[r]->(n2:Entity)
+                WHERE ($subj IS NULL OR n1.id = $subj)
+                AND ($obj IS NULL OR n2.id = $obj)
+                AND ($rel IS NULL OR type(r) = $rel)
+                RETURN n1.id AS subj, n2.id AS obj, 
+                type(r) AS rel, r.timestamp AS timestamp
+            """
+
+        # Construct the query parameters
+        params = {
+            "subj": subj
+            if subj is not None
+            else None,  # If subj is None, match any subject node
+            "obj": obj
+            if obj is not None
+            else None,  # If obj is None, match any object node
+            "rel": rel
+            if rel is not None
+            else None,  # If rel is None, match any relationship type
+        }
+
+        logger.debug(f"Executing query: {query}")
+        logger.debug(f"Query parameters: {params}")
+
+        with self.driver.session(database=self.database) as session:
+            try:
+                result = session.run(query, params)
+                records = [record.data() for record in result]
+                logger.debug(
+                    f"Query returned {len(records)} records: {records}"
+                )
+                return records
+            except Exception as e:
+                logger.error(f"Error executing query: {e}")
+                return []

camel/toolkits/__init__.py

@@ -58,6 +58,7 @@ from .mcp_toolkit import MCPToolkit
 from .web_toolkit import WebToolkit
 from .file_write_toolkit import FileWriteToolkit
 from .terminal_toolkit import TerminalToolkit
+from .pubmed_toolkit import PubMedToolkit
 
 
 __all__ = [
@@ -104,4 +105,5 @@ __all__ = [
     'WebToolkit',
     'FileWriteToolkit',
     'TerminalToolkit',
+    'PubMedToolkit',
 ]