camel-ai 0.2.14__py3-none-any.whl → 0.2.15__py3-none-any.whl

camel/storages/graph_storages/neo4j_graph.py

@@ -583,3 +583,141 @@ class Neo4jGraph(BaseGraphStorage):
                     ]
                 },
             )
+
+    def random_walk_with_restarts(
+        self,
+        graph_name: str,
+        sampling_ratio: float,
+        start_node_ids: List[int],
+        restart_probability: float = 0.1,
+        node_label_stratification: bool = False,
+        relationship_weight_property: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        r"""Runs the Random Walk with Restarts (RWR) sampling algorithm.
+
+        Args:
+            graph_name (str): The name of the original graph in the graph
+                catalog.
+            sampling_ratio (float): The fraction of nodes in the original
+                graph to be sampled.
+            start_node_ids (List[int]): IDs of the initial set of nodes of the
+                original graph from which the sampling random walks will start.
+            restart_probability (float, optional): The probability that a
+                sampling random walk restarts from one of the start nodes.
+                Defaults to `0.1`.
+            node_label_stratification (bool, optional): If true, preserves the
+                node label distribution of the original graph. Defaults to
+                `False`.
+            relationship_weight_property (Optional[str], optional): Name of
+                the relationship property to use as weights. If unspecified,
+                the algorithm runs unweighted. Defaults to `None`.
+
+        Returns:
+            Dict[str, Any]: A dictionary with the results of the RWR sampling.
+        """
+        from neo4j.exceptions import ClientError, CypherSyntaxError
+
+        try:
+            self.query(query="CALL gds.version() YIELD version RETURN version")
+        except ClientError:
+            raise ValueError(
+                "Graph Data Science (GDS) library is not installed or not"
+                " available. Reference: https://neo4j.com/docs/graph-data-science/current/installation/"
+            )
+
+        query = """
+        CALL gds.graph.sample.rwr($graphName, $fromGraphName, {
+            samplingRatio: $samplingRatio,
+            startNodes: $startNodes,
+            restartProbability: $restartProbability,
+            nodeLabelStratification: $nodeLabelStratification,
+            relationshipWeightProperty: $relationshipWeightProperty
+        })
+        YIELD graphName, fromGraphName, nodeCount, 
+        relationshipCount, startNodeCount, projectMillis
+        RETURN graphName, fromGraphName, nodeCount, 
+        relationshipCount, startNodeCount, projectMillis
+        """
+
+        params = {
+            "graphName": f"{graph_name}_sampled",
+            "fromGraphName": graph_name,
+            "samplingRatio": sampling_ratio,
+            "startNodes": start_node_ids,
+            "restartProbability": restart_probability,
+            "nodeLabelStratification": node_label_stratification,
+            "relationshipWeightProperty": relationship_weight_property,
+        }
+
+        try:
+            result = self.query(query, params)
+            return result[0] if result else {}
+        except CypherSyntaxError as e:
+            raise ValueError(f"Generated Cypher Statement is not valid\n{e}")
+
+    def common_neighbour_aware_random_walk(
+        self,
+        graph_name: str,
+        sampling_ratio: float,
+        start_node_ids: List[int],
+        node_label_stratification: bool = False,
+        relationship_weight_property: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        r"""Runs the Common Neighbour Aware Random Walk (CNARW) sampling
+        algorithm.
+
+        Args:
+            graph_name (str): The name of the original graph in the graph
+                catalog.
+            sampling_ratio (float): The fraction of nodes in the original
+                graph to be sampled.
+            start_node_ids (List[int]): IDs of the initial set of nodes of the
+                original graph from which the sampling random walks will start.
+            node_label_stratification (bool, optional): If true, preserves the
+                node label distribution of the original graph. Defaults to
+                `False`.
+            relationship_weight_property (Optional[str], optional): Name of
+                the relationship property to use as weights. If unspecified,
+                the algorithm runs unweighted. Defaults to `None`.
+
+        Returns:
+            Dict[str, Any]: A dictionary with the results of the CNARW
+                sampling.
+        """
+        from neo4j.exceptions import ClientError, CypherSyntaxError
+
+        try:
+            self.query(query="CALL gds.version() YIELD version RETURN version")
+        except ClientError:
+            raise ValueError(
+                "Graph Data Science (GDS) library is not installed or not"
+                " available. Reference: https://neo4j.com/docs/graph-data-science/current/installation/"
+            )
+
+        query = """
+        CALL gds.graph.sample.cnarw($graphName, $fromGraphName, {
+            samplingRatio: $samplingRatio,
+            startNodes: $startNodes,
+            nodeLabelStratification: $nodeLabelStratification,
+            relationshipWeightProperty: $relationshipWeightProperty
+        })
+        YIELD graphName, fromGraphName, nodeCount, 
+        relationshipCount, startNodeCount, projectMillis
+        RETURN graphName, fromGraphName, nodeCount, 
+        relationshipCount, startNodeCount, projectMillis
+        """
+
+        params = {
+            "graphName": f"{graph_name}_sampled_cnarw",
+            "fromGraphName": graph_name,
+            "samplingRatio": sampling_ratio,
+            "startNodes": start_node_ids,
+            "nodeLabelStratification": node_label_stratification,
+            "relationshipWeightProperty": relationship_weight_property,
+        }
+
+        try:
+            result = self.query(query, params)
+            return result[0] if result else {}
+        except CypherSyntaxError as e:
+            raise ValueError(f"Generated Cypher Statement is not valid\n{e}")

camel/toolkits/__init__.py

@@ -28,6 +28,7 @@ from .ask_news_toolkit import AskNewsToolkit, AsyncAskNewsToolkit
 from .linkedin_toolkit import LinkedInToolkit
 from .reddit_toolkit import RedditToolkit
 from .meshy_toolkit import MeshyToolkit
+from .openbb_toolkit import OpenBBToolkit
 
 from .base import BaseToolkit
 from .google_maps_toolkit import GoogleMapsToolkit
@@ -73,4 +74,5 @@ __all__ = [
     'VideoDownloaderToolkit',
     'StripeToolkit',
     'MeshyToolkit',
+    'OpenBBToolkit',
 ]

camel/toolkits/arxiv_toolkit.py

@@ -14,10 +14,13 @@
 
 from typing import Dict, Generator, List, Optional
 
+from camel.logger import get_logger
 from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
 from camel.utils import dependencies_required
 
+logger = get_logger(__name__)
+
 
 class ArxivToolkit(BaseToolkit):
     r"""A toolkit for interacting with the arXiv API to search and download
@@ -98,10 +101,24 @@ class ArxivToolkit(BaseToolkit):
                 "authors": [author.name for author in paper.authors],
                 "entry_id": paper.entry_id,
                 "summary": paper.summary,
-                # TODO: Use chunkr instead of atxiv_to_text for better
-                # performance
-                "paper_text": arxiv_to_text(paper.pdf_url),
+                "pdf_url": paper.pdf_url,
             }
+
+            # Extract text from the paper
+            try:
+                # TODO: Use chunkr instead of atxiv_to_text for better
+                # performance and reliability
+                text = arxiv_to_text(paper_info["pdf_url"])
+            except Exception as e:
+                logger.error(
+                    "Failed to extract text content from the PDF at "
+                    "the specified URL. "
+                    f"URL: {paper_info.get('pdf_url', 'Unknown')} | Error: {e}"
+                )
+                text = ""
+
+            paper_info['paper_text'] = text
+
             papers_data.append(paper_info)
 
         return papers_data

camel/toolkits/function_tool.py

@@ -14,6 +14,7 @@
 import ast
 import inspect
 import logging
+import textwrap
 import warnings
 from inspect import Parameter, getsource, signature
 from typing import Any, Callable, Dict, Mapping, Optional, Tuple, Type
@@ -24,7 +25,6 @@ from jsonschema.validators import Draft202012Validator as JSONValidator
 from pydantic import BaseModel, create_model
 from pydantic.fields import FieldInfo
 
-from camel.agents import ChatAgent
 from camel.models import BaseModelBackend, ModelFactory
 from camel.types import ModelPlatformType, ModelType
 from camel.utils import get_pydantic_object_schema, to_pascal
@@ -237,41 +237,43 @@ def generate_docstring(
     Returns:
         str: The generated docstring.
     """
-    # Create the docstring prompt
-    docstring_prompt = '''
-    **Role**: Generate professional Python docstrings conforming to 
-    PEP 8/PEP 257.
 
-    **Requirements**:
-    - Use appropriate format: reST, Google, or NumPy, as needed.
-    - Include parameters, return values, and exceptions.
-    - Reference any existing docstring in the function and 
-      retain useful information.
+    from camel.agents import ChatAgent
 
-    **Input**: Python function.
+    # Create the docstring prompt
+    docstring_prompt = textwrap.dedent(
+        """\
+        **Role**: Generate professional Python docstrings conforming to PEP 8/PEP 257.
 
-    **Output**: Docstring content (plain text, no code markers).
+        **Requirements**:
+        - Use appropriate format: reST, Google, or NumPy, as needed.
+        - Include parameters, return values, and exceptions.
+        - Reference any existing docstring in the function and retain useful information.
 
-    **Example:**
+        **Input**: Python function.
 
-    Input:
-    ```python
-    def add(a: int, b: int) -> int:
-        return a + b
-    ```
+        **Output**: Docstring content (plain text, no code markers).
 
-    Output:
-    Adds two numbers.
-    Args:
-        a (int): The first number.
-        b (int): The second number.
+        **Example:**
 
-    Returns:
-        int: The sum of the two numbers.
+        Input:
+        ```python
+        def add(a: int, b: int) -> int:
+            return a + b
+        ```
 
-    **Task**: Generate a docstring for the function below.
+        Output:
+        Adds two numbers.
+        Args:
+            a (int): The first number.
+            b (int): The second number.
+
+        Returns:
+            int: The sum of the two numbers.
 
-    '''
+        **Task**: Generate a docstring for the function below.
+        """  # noqa: E501
+    )
     # Initialize assistant with system message and model
     assistant_sys_msg = "You are a helpful assistant."
     docstring_assistant = ChatAgent(assistant_sys_msg, model=model)
@@ -665,7 +667,7 @@ class FunctionTool:
             Any: Synthesized output from the function execution. If no
                 synthesis model is provided, a warning is logged.
         """
-        import textwrap
+        from camel.agents import ChatAgent
 
         # Retrieve the function source code
         function_string = inspect.getsource(self.func)
@@ -694,39 +696,37 @@ class FunctionTool:
             function_string += f"\nkwargs:\n{kwargs}"
 
         # Define the assistant system message
-        assistant_sys_msg = '''
-**Role:** AI Assistant specialized in synthesizing tool execution outputs
-without actual execution.
-
-**Capabilities:**
-- Analyzes function to understand their
-  purpose and expected outputs.
-- Generates synthetic outputs based on the function logic.
-- Ensures the synthesized output is contextually accurate and aligns with the
-  function's intended behavior.
-
-**Instructions:**
-1. **Input:** Provide the function code, function docstring, args, and kwargs.
-2. **Output:** Synthesize the expected output of the function based on the
-   provided args and kwargs.
-
-**Example:**
-- **User Input:**
-def sum(a, b, c=0):
-    """Adds three numbers together."""
-    return a + b + c
-
-- **Input Arguments:**
-args: (1, 2)
-kwargs: {"c": 3}
-
-- **Output:**
-6
-
-**Note:**
-- Just return the synthesized output of the function without any explanation.
-- The output should be in plain text without any formatting.
-'''
+        assistant_sys_msg = textwrap.dedent(
+            '''\
+            **Role:** AI Assistant specialized in synthesizing tool execution outputs without actual execution.
+
+            **Capabilities:**
+            - Analyzes function to understand their purpose and expected outputs.
+            - Generates synthetic outputs based on the function logic.
+            - Ensures the synthesized output is contextually accurate and aligns with the function's intended behavior.
+
+            **Instructions:**
+            1. **Input:** Provide the function code, function docstring, args, and kwargs.
+            2. **Output:** Synthesize the expected output of the function based on the provided args and kwargs.
+
+            **Example:**
+            - **User Input:**
+            def sum(a, b, c=0):
+                """Adds three numbers together."""
+                return a + b + c
+
+            - **Input Arguments:**
+            args: (1, 2)
+            kwargs: {"c": 3}
+
+            - **Output:**
+            6
+
+            **Note:**
+            - Just return the synthesized output of the function without any explanation.
+            - The output should be in plain text without any formatting.
+            '''  # noqa: E501
+        )
 
         # Initialize the synthesis agent
         synthesis_agent = ChatAgent(

camel/toolkits/meshy_toolkit.py

@@ -33,7 +33,11 @@ class MeshyToolkit(BaseToolkit):
     https://docs.meshy.ai/api-text-to-3d-beta#create-a-text-to-3d-preview-task
     """
 
-    @api_keys_required("MESHY_API_KEY")
+    @api_keys_required(
+        [
+            (None, 'MESHY_API_KEY'),
+        ]
+    )
     def __init__(self):
         r"""Initializes the MeshyToolkit with the API key from the
         environment.

camel/toolkits/notion_toolkit.py

@@ -71,7 +71,7 @@ class NotionToolkit(BaseToolkit):
 
     Attributes:
         notion_token (Optional[str], optional): The notion_token used to
-            interact with notion APIs.(default: :obj:`None`)
+            interact with notion APIs. (default: :obj:`None`)
         notion_client (module): The notion module for interacting with
             the notion APIs.
     """