camel-ai 0.2.22__py3-none-any.whl → 0.2.23__py3-none-any.whl

camel/toolkits/mineru_toolkit.py

@@ -111,7 +111,7 @@ class MinerUToolkit(BaseToolkit):
             if self.wait:
                 return self.client.wait_for_completion(
                     response['task_id'],
-                    timeout=self.timeout,
+                    timeout=self.timeout,  # type: ignore[arg-type]
                 )
             return response
         else:
@@ -125,7 +125,7 @@ class MinerUToolkit(BaseToolkit):
                 return self.client.wait_for_completion(
                     batch_id,
                     is_batch=True,
-                    timeout=self.timeout if self.timeout > 300 else 600,
+                    timeout=self.timeout if self.timeout > 300 else 600,  # type: ignore[arg-type,operator]
                 )
             return {"batch_id": batch_id}
 

camel/toolkits/networkx_toolkit.py

@@ -0,0 +1,240 @@
+# ========= 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 json
+from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
+
+from camel.logger import get_logger
+from camel.toolkits import FunctionTool
+from camel.toolkits.base import BaseToolkit
+
+logger = get_logger(__name__)
+
+
+class NetworkXToolkit(BaseToolkit):
+    _nx = None  # Class variable to store the networkx module
+
+    @classmethod
+    def _get_nx(cls):
+        r"""Lazily import networkx module when needed."""
+        if cls._nx is None:
+            import networkx
+
+            cls._nx = networkx
+        return cls._nx
+
+    def __init__(
+        self,
+        graph_type: Literal[
+            'graph', 'digraph', 'multigraph', 'multidigraph'
+        ] = 'graph',
+    ):
+        r"""Initializes the NetworkX graph client.
+
+        Args:
+            graph_type (Literal['graph', 'digraph', 'multigraph',
+            'multidigraph']):
+                Type of graph to create. Options are:
+                - 'graph': Undirected graph
+                - 'digraph': Directed graph
+                - 'multigraph': Undirected graph with parallel edges
+                - 'multidigraph': Directed graph with parallel edges
+                (default: :obj:`'graph'`)
+        """
+        nx = self._get_nx()
+        graph_types = {
+            'graph': nx.Graph,
+            'digraph': nx.DiGraph,
+            'multigraph': nx.MultiGraph,
+            'multidigraph': nx.MultiDiGraph,
+        }
+        graph_class = graph_types.get(graph_type.lower())
+        if graph_class is None:
+            raise ValueError(
+                f"Invalid graph type: {graph_type}. Must be one "
+                f"of: {list(graph_types.keys())}"
+            )
+
+        self.graph = graph_class()
+        logger.info(f"Initialized NetworkX {graph_type} instance.")
+
+    def add_node(self, node_id: str, **attributes: Any) -> None:
+        r"""Adds a node to the graph.
+
+        Args:
+            node_id (str): The ID of the node.
+            attributes (dict): Additional node attributes.
+        """
+        logger.info(f"Adding node: {node_id}, attributes: {attributes}")
+        self.graph.add_node(node_id, **attributes)
+
+    def add_edge(self, source: str, target: str, **attributes: Any) -> None:
+        r"""Adds an edge to the graph.
+
+        Args:
+            source (str): Source node ID.
+            target (str): Target node ID.
+            attributes (dict): Additional edge attributes.
+        """
+        logger.info(
+            f"Adding edge: {source} -> {target}, attributes: {attributes}"
+        )
+        self.graph.add_edge(source, target, **attributes)
+
+    def get_nodes(self) -> List[str]:
+        r"""Returns all nodes in the graph.
+
+        Returns:
+            List[str]: A list of node IDs.
+        """
+        logger.info("Fetching all nodes.")
+        return list(self.graph.nodes)
+
+    def get_edges(self) -> List[Tuple[str, str]]:
+        r"""Returns all edges in the graph.
+
+        Returns:
+            List[Tuple[str, str]]: A list of edges as (source, target).
+        """
+        logger.info("Fetching all edges.")
+        return list(self.graph.edges)
+
+    def get_shortest_path(
+        self,
+        source: str,
+        target: str,
+        weight: Optional[Union[str, Callable]] = None,
+        method: Literal['dijkstra', 'bellman-ford'] = 'dijkstra',
+    ) -> List[str]:
+        r"""Finds the shortest path between two nodes.
+
+        Args:
+            source (str): The source node ID.
+            target (str): The target node ID.
+            weight (None, str or function, optional): Edge weights/distances.
+                If None, every edge has weight/distance/cost 1.
+                If string, use this edge attribute as the edge weight.
+                If function, the weight of an edge is the value returned by
+                the function. The function must accept three positional
+                arguments: the two endpoints and the edge attribute
+                dictionary. (default: :obj:`None`)
+            method (Literal['dijkstra', 'bellman-ford'], optional): Algorithm
+                to compute the path. Ignored if weight is None. (default:
+                :obj:`'dijkstra'`)
+
+        Returns:
+            List[str]: A list of nodes in the shortest path.
+        """
+        logger.info(
+            f"Finding shortest path from '{source}' to '{target}' "
+            f"using {method} algorithm"
+        )
+        try:
+            nx = self._get_nx()
+            path = nx.shortest_path(
+                self.graph,
+                source=source,
+                target=target,
+                weight=weight,
+                method=method,
+            )
+            logger.debug(f"Found path: {' -> '.join(path)}")
+            return path
+        except nx.NetworkXNoPath:
+            error_msg = f"No path exists between '{source}' and '{target}'"
+            logger.error(error_msg)
+            return [error_msg]
+        except nx.NodeNotFound as e:
+            error_msg = f"Node not found in graph: {e!s}"
+            logger.error(error_msg)
+            return [error_msg]
+
+    def compute_centrality(self) -> Dict[str, float]:
+        r"""Computes centrality measures for the graph.
+
+        Returns:
+            Dict[str, float]: Centrality values for each node.
+        """
+        logger.info("Computing centrality measures.")
+        nx = self._get_nx()
+        return nx.degree_centrality(self.graph)
+
+    def serialize_graph(self) -> str:
+        r"""Serializes the graph to a JSON string.
+
+        Returns:
+            str: The serialized graph in JSON format.
+        """
+        logger.info("Serializing the graph.")
+        nx = self._get_nx()
+        return json.dumps(nx.node_link_data(self.graph))
+
+    def deserialize_graph(self, data: str) -> None:
+        r"""Loads a graph from a serialized JSON string.
+
+        Args:
+            data (str): The JSON string representing the graph.
+        """
+        logger.info("Deserializing graph from JSON data.")
+        nx = self._get_nx()
+        self.graph = nx.node_link_graph(json.loads(data))
+
+    def export_to_file(self, file_path: str) -> None:
+        r"""Exports the graph to a file in JSON format.
+
+        Args:
+            file_path (str): The file path to save the graph.
+        """
+        logger.info(f"Exporting graph to file: {file_path}")
+        nx = self._get_nx()
+        with open(file_path, "w") as file:
+            json.dump(nx.node_link_data(self.graph), file)
+
+    def import_from_file(self, file_path: str) -> None:
+        r"""Imports a graph from a JSON file.
+
+        Args:
+            file_path (str): The file path to load the graph from.
+        """
+        logger.info(f"Importing graph from file: {file_path}")
+        nx = self._get_nx()
+        with open(file_path, "r") as file:
+            self.graph = nx.node_link_graph(json.load(file))
+
+    def clear_graph(self) -> None:
+        r"""Clears the current graph."""
+        logger.info("Clearing the graph.")
+        self.graph.clear()
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects for the
+                toolkit methods.
+        """
+        return [
+            FunctionTool(self.add_edge),
+            FunctionTool(self.add_node),
+            FunctionTool(self.clear_graph),
+            FunctionTool(self.compute_centrality),
+            FunctionTool(self.deserialize_graph),
+            FunctionTool(self.export_to_file),
+            FunctionTool(self.get_edges),
+            FunctionTool(self.get_nodes),
+            FunctionTool(self.import_from_file),
+            FunctionTool(self.serialize_graph),
+            FunctionTool(self.get_shortest_path),
+        ]

camel/toolkits/notion_toolkit.py

@@ -79,6 +79,7 @@ class NotionToolkit(BaseToolkit):
     def __init__(
         self,
         notion_token: Optional[str] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         r"""Initializes the NotionToolkit.
 
@@ -86,6 +87,7 @@ class NotionToolkit(BaseToolkit):
             notion_token (Optional[str], optional): The optional notion_token
                 used to interact with notion APIs.(default: :obj:`None`)
         """
+        super().__init__(timeout=timeout)
         from notion_client import Client
 
         self.notion_token = notion_token or os.environ.get("NOTION_TOKEN")

camel/toolkits/openbb_toolkit.py

@@ -37,15 +37,16 @@ class OpenBBToolkit(BaseToolkit):
             (None, "OPENBB_TOKEN"),
         ]
     )
-    def __init__(self) -> None:
+    def __init__(self, timeout: Optional[float] = None) -> None:
         r"""Initialize the OpenBBToolkit.
 
         This method sets up the OpenBB client and initializes the OpenBB
         Hub account system.
         """
+        super().__init__(timeout=timeout)
         import os
 
-        from openbb import obb
+        from openbb import obb  # type: ignore[import-not-found]
 
         self.client = obb
         # Initialize OpenBB Hub account with access token

camel/toolkits/page_script.js

@@ -0,0 +1,376 @@
+var MultimodalWebSurfer = MultimodalWebSurfer || (function() {
+    let nextLabel = 10;
+  
+    let roleMapping = {
+        "a": "link",
+        "area": "link",
+        "button": "button",
+        "input, type=button": "button",
+        "input, type=checkbox": "checkbox",
+        "input, type=email": "textbox",
+        "input, type=number": "spinbutton",
+        "input, type=radio": "radio",
+        "input, type=range": "slider",
+        "input, type=reset": "button",
+        "input, type=search": "searchbox",
+        "input, type=submit": "button",
+        "input, type=tel": "textbox",
+        "input, type=text": "textbox",
+        "input, type=url": "textbox",
+        "search": "search",
+        "select": "combobox",
+        "option": "option",
+        "textarea": "textbox"
+    };
+  
+    let getCursor = function(elm) {
+        return window.getComputedStyle(elm)["cursor"];
+    };
+  
+    let getInteractiveElements = function() {
+  
+        let results = []
+        let roles = ["scrollbar", "searchbox", "slider", "spinbutton", "switch", "tab", "treeitem", "button", "checkbox", "gridcell", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "progressbar", "radio", "textbox", "combobox", "menu", "tree", "treegrid", "grid", "listbox", "radiogroup", "widget"];
+        let inertCursors = ["auto", "default", "none", "text", "vertical-text", "not-allowed", "no-drop"];
+  
+        // Get the main interactive elements
+        let nodeList = document.querySelectorAll("input, select, textarea, button, [href], [onclick], [contenteditable], [tabindex]:not([tabindex='-1'])");
+        for (let i=0; i<nodeList.length; i++) { // Copy to something mutable
+            results.push(nodeList[i]);
+        }
+  
+        // Anything not already included that has a suitable role
+        nodeList = document.querySelectorAll("[role]");
+        for (let i=0; i<nodeList.length; i++) { // Copy to something mutable
+            if (results.indexOf(nodeList[i]) == -1) {
+                let role = nodeList[i].getAttribute("role");
+            if (roles.indexOf(role) > -1) {
+                    results.push(nodeList[i]);
+            }
+        }
+        }
+  
+        // Any element that changes the cursor to something implying interactivity
+        nodeList = document.querySelectorAll("*");
+        for (let i=0; i<nodeList.length; i++) {
+           let node = nodeList[i];
+  
+           // Cursor is default, or does not suggest interactivity
+           let cursor = getCursor(node);
+           if (inertCursors.indexOf(cursor) >= 0) {
+               continue;
+           }
+  
+           // Move up to the first instance of this cursor change
+           parent = node.parentNode;
+           while (parent && getCursor(parent) == cursor) {
+               node = parent;
+           parent = node.parentNode;
+           }
+  
+           // Add the node if it is new
+           if (results.indexOf(node) == -1) {
+               results.push(node);
+           }
+        }
+  
+        return results;
+    };
+  
+    let labelElements = function(elements) {
+        for (let i=0; i<elements.length; i++) {
+            if (!elements[i].hasAttribute("__elementId")) {
+                elements[i].setAttribute("__elementId", "" + (nextLabel++));
+            }
+        }
+    };
+  
+    let isTopmost = function(element, x, y) {
+       let hit = document.elementFromPoint(x, y);
+  
+       // Hack to handle elements outside the viewport
+       if (hit === null) {
+           return true; 
+       }
+  
+       while (hit) {
+           if (hit == element) return true;
+           hit = hit.parentNode;
+       }
+       return false;
+    };
+  
+    let getFocusedElementId = function() {
+       let elm = document.activeElement;
+       while (elm) {
+           if (elm.hasAttribute && elm.hasAttribute("__elementId")) {
+           return elm.getAttribute("__elementId");
+       }
+           elm = elm.parentNode;
+       }
+       return null;
+    };
+  
+    let trimmedInnerText = function(element) {
+        if (!element) {
+            return "";
+        }
+        let text = element.innerText;
+        if (!text) {
+            return "";
+        }
+        return text.trim();
+    };
+  
+    let getApproximateAriaName = function(element) {
+        // Check for aria labels
+        if (element.hasAttribute("aria-labelledby")) {
+            let buffer = "";
+        let ids = element.getAttribute("aria-labelledby").split(" ");
+        for (let i=0; i<ids.length; i++) {
+                let label = document.getElementById(ids[i]);
+            if (label) {
+                buffer = buffer + " " + trimmedInnerText(label);
+                }
+            }
+        return buffer.trim();
+        }
+  
+        if (element.hasAttribute("aria-label")) {
+        return element.getAttribute("aria-label");
+        }
+  
+        // Check for labels
+        if (element.hasAttribute("id")) {
+            let label_id = element.getAttribute("id");
+            let label = "";
+            let labels = document.querySelectorAll("label[for='" + label_id + "']");
+            for (let j=0; j<labels.length; j++) {
+                label += labels[j].innerText + " ";
+            }
+            label = label.trim();
+            if (label != "") {
+                return label;
+            }
+        }
+  
+        if (element.parentElement && element.parentElement.tagName == "LABEL") {
+            return element.parentElement.innerText;
+        }
+  
+        // Check for alt text or titles
+        if (element.hasAttribute("alt")) {
+        return element.getAttribute("alt")
+        }
+  
+        if (element.hasAttribute("title")) {
+        return element.getAttribute("title")
+        }
+  
+        return trimmedInnerText(element);
+    };
+  
+    let getApproximateAriaRole = function(element) {
+        let tag = element.tagName.toLowerCase();
+        if (tag == "input" && element.hasAttribute("type")) {
+            tag = tag + ", type=" + element.getAttribute("type");
+        }
+  
+        if (element.hasAttribute("role")) {
+            return [element.getAttribute("role"), tag];
+        }
+        else if (tag in roleMapping) {
+            return [roleMapping[tag], tag];
+        }
+        else {
+        return ["", tag];
+        }
+    };
+  
+    let getInteractiveRects = function() {
+        labelElements(getInteractiveElements());
+        let elements = document.querySelectorAll("[__elementId]");
+        let results = {};
+        for (let i=0; i<elements.length; i++) {
+           let key = elements[i].getAttribute("__elementId");
+           let rects = elements[i].getClientRects();
+       let ariaRole = getApproximateAriaRole(elements[i]);
+       let ariaName = getApproximateAriaName(elements[i]);
+       let vScrollable = elements[i].scrollHeight - elements[i].clientHeight >= 1;
+  
+       let record = {
+               "tag_name": ariaRole[1],
+           "role": ariaRole[0],
+           "aria-name": ariaName,
+           "v-scrollable": vScrollable,
+           "rects": []
+       };
+  
+           for (const rect of rects) {
+           let x = rect.left + rect.width/2;
+               let y = rect.top + rect.height/2;
+               if (isTopmost(elements[i], x, y)) {
+           record["rects"].push(JSON.parse(JSON.stringify(rect)));
+               }
+           }
+  
+       if (record["rects"].length > 0) {
+               results[key] = record;
+           }
+        }
+        return results;
+    };
+  
+    let getVisualViewport = function() {
+        let vv = window.visualViewport;
+        let de = document.documentElement;
+        return {
+            "height":     vv ? vv.height : 0,
+        "width":      vv ? vv.width : 0,
+        "offsetLeft": vv ? vv.offsetLeft : 0,
+        "offsetTop":  vv ? vv.offsetTop : 0,
+        "pageLeft":   vv ? vv.pageLeft  : 0,
+        "pageTop":    vv ? vv.pageTop : 0,
+        "scale":      vv ? vv.scale : 0,
+        "clientWidth":  de ? de.clientWidth : 0,
+        "clientHeight": de ? de.clientHeight : 0,
+        "scrollWidth":  de ? de.scrollWidth : 0,
+        "scrollHeight": de ? de.scrollHeight : 0
+        };
+    };
+  
+    let _getMetaTags = function() {
+        let meta = document.querySelectorAll("meta");
+        let results = {};
+        for (let i = 0; i<meta.length; i++) {
+            let key = null;
+            if (meta[i].hasAttribute("name")) {
+                key = meta[i].getAttribute("name");
+            }
+            else if (meta[i].hasAttribute("property")) {
+                key = meta[i].getAttribute("property");
+            }
+            else {
+                continue;
+            }
+            if (meta[i].hasAttribute("content")) {
+                results[key] = meta[i].getAttribute("content");
+            }
+        }
+        return results;
+    };
+  
+    let _getJsonLd = function() {
+        let jsonld = [];
+        let scripts = document.querySelectorAll('script[type="application/ld+json"]');
+        for (let i=0; i<scripts.length; i++) {
+            jsonld.push(scripts[i].innerHTML.trim());
+        }
+        return jsonld;
+     };
+  
+     // From: https://www.stevefenton.co.uk/blog/2022/12/parse-microdata-with-javascript/
+     let _getMicrodata = function() {
+        function sanitize(input) {
+            return input.replace(/\s/gi, ' ').trim();
+        }
+  
+        function addValue(information, name, value) {
+            if (information[name]) {
+                if (typeof information[name] === 'array') {
+                    information[name].push(value);
+                } else {
+                    const arr = [];
+                    arr.push(information[name]);
+                    arr.push(value);
+                    information[name] = arr;
+                }
+            } else {
+                information[name] = value;
+            }
+        }
+  
+        function traverseItem(item, information) {
+           const children = item.children;
+          
+           for (let i = 0; i < children.length; i++) {
+               const child = children[i];
+  
+               if (child.hasAttribute('itemscope')) {
+                   if (child.hasAttribute('itemprop')) {
+                       const itemProp = child.getAttribute('itemprop');
+                       const itemType = child.getAttribute('itemtype');
+  
+                       const childInfo = {
+                           itemType: itemType
+                       };
+  
+                       traverseItem(child, childInfo);
+  
+                       itemProp.split(' ').forEach(propName => {
+                           addValue(information, propName, childInfo);
+                       });
+                   }
+  
+               } else if (child.hasAttribute('itemprop')) {
+                   const itemProp = child.getAttribute('itemprop');
+                   itemProp.split(' ').forEach(propName => {
+                       if (propName === 'url') {
+                           addValue(information, propName, child.href);
+                       } else {
+                           addValue(information, propName, sanitize(child.getAttribute("content") || child.content || child.textContent || child.src || ""));
+                       }
+                   });
+                   traverseItem(child, information);
+               } else {
+                   traverseItem(child, information);
+               }
+           }
+        }
+  
+        const microdata = [];
+  
+        document.querySelectorAll("[itemscope]").forEach(function(elem, i) {
+           const itemType = elem.getAttribute('itemtype');
+           const information = {
+               itemType: itemType
+           };
+           traverseItem(elem, information);
+           microdata.push(information);
+        });
+      
+        return microdata;
+     };
+  
+     let getPageMetadata = function() {
+         let jsonld = _getJsonLd();
+         let metaTags = _getMetaTags();
+         let microdata = _getMicrodata();
+         let results = {}
+         if (jsonld.length > 0) {
+             try {
+                 results["jsonld"] = JSON.parse(jsonld);
+             } 
+         catch (e) {
+                 results["jsonld"] = jsonld;
+         }
+         }
+         if (microdata.length > 0) {
+         results["microdata"] = microdata;
+         }
+         for (let key in metaTags) {
+         if (metaTags.hasOwnProperty(key)) {
+             results["meta_tags"] = metaTags;
+             break;
+             }
+         }
+         return results;
+     };	
+  
+     return {
+         getInteractiveRects: getInteractiveRects,
+         getVisualViewport: getVisualViewport,
+         getFocusedElementId: getFocusedElementId,
+         getPageMetadata: getPageMetadata,
+     };
+  })();