opentools-->octotools; added remaining tools; polished the ui

octotools/tools/README.md

@@ -1,44 +0,0 @@
-
-## Testing the Tools
-
-To test the text detection tool, follow these steps:
-
-1. **Navigate to the Project Directory:**
-
-   Change your current directory to where the tools are located. Replace `your_path` with the actual path to your project directory.
-
-   ```sh
-   cd your_path/toolbox-agent/octotools
-   ```
-
-2. **Run the Text Detection Tool:**
-
-   ```sh
-   cd toolbox-agent
-   export PYTHONPATH=$(pwd)
-   ```
-
-
-   Execute the tool using the following command:
-
-   ```sh
-   python tools/text_detector/tool.py
-
-   python tools/object_detector/tool.py
-
-   ```
-
-## File Structure
-
-The project is organized as follows:
-
-```sh
-├── __init__.py              # Initializes the tools package and possibly exposes submodules
-├── base.py                  # Base class for tools, providing common functionality
-├── text_detector/           # Directory for the text detection tool
-│   ├── readme.md            # Documentation for the text detection tool
-│   └── tool.py              # Implementation of the text detection tool
-├── object_detector/         # Directory for the object detection tool
-│   ├── readme.md            # Documentation for the object detection tool
-│   └── tool.py              # Implementation of the object detection tool
-```

octotools/tools/advanced_object_detector/test.log

@@ -1,366 +0,0 @@
-{'code': 0, 'msg': 'ok', 'data': {'task_uuid': '2d4337f5-403d-419b-9832-64b0f888f146'}}
-task_uuid:2d4337f5-403d-419b-9832-64b0f888f146
-[
-    {
-        "label": "baseball",
-        "confidence score": 0.73,
-        "box": [
-            614,
-            137,
-            671,
-            191
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_1.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.73,
-        "box": [
-            114,
-            377,
-            171,
-            431
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_2.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.72,
-        "box": [
-            632,
-            67,
-            689,
-            126
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_3.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.72,
-        "box": [
-            132,
-            67,
-            189,
-            126
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_4.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.71,
-        "box": [
-            382,
-            67,
-            439,
-            126
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_5.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.71,
-        "box": [
-            364,
-            137,
-            421,
-            191
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_6.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.71,
-        "box": [
-            132,
-            307,
-            189,
-            366
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_7.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.71,
-        "box": [
-            114,
-            136,
-            171,
-            191
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_8.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.7,
-        "box": [
-            57,
-            49,
-            115,
-            107
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_9.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.69,
-        "box": [
-            307,
-            49,
-            365,
-            106
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_10.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.68,
-        "box": [
-            57,
-            289,
-            115,
-            346
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_11.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.68,
-        "box": [
-            86,
-            335,
-            143,
-            393
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_12.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.68,
-        "box": [
-            557,
-            49,
-            615,
-            107
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_13.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.68,
-        "box": [
-            35,
-            352,
-            92,
-            410
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_14.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.68,
-        "box": [
-            86,
-            95,
-            143,
-            153
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_15.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.67,
-        "box": [
-            586,
-            95,
-            643,
-            153
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_16.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.66,
-        "box": [
-            285,
-            111,
-            342,
-            169
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_17.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.66,
-        "box": [
-            35,
-            111,
-            91,
-            170
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_18.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.66,
-        "box": [
-            535,
-            111,
-            592,
-            169
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_19.png"
-    },
-    {
-        "label": "baseball",
-        "confidence score": 0.66,
-        "box": [
-            337,
-            95,
-            393,
-            153
-        ],
-        "saved_image_path": "detected_objects/baseball_baseball_20.png"
-    },
-    {
-        "label": "basket",
-        "confidence score": 0.41,
-        "box": [
-            1,
-            2,
-            218,
-            216
-        ],
-        "saved_image_path": "detected_objects/baseball_basket_1.png"
-    },
-    {
-        "label": "basket",
-        "confidence score": 0.39,
-        "box": [
-            501,
-            2,
-            718,
-            216
-        ],
-        "saved_image_path": "detected_objects/baseball_basket_2.png"
-    },
-    {
-        "label": "basket",
-        "confidence score": 0.38,
-        "box": [
-            2,
-            242,
-            218,
-            456
-        ],
-        "saved_image_path": "detected_objects/baseball_basket_3.png"
-    },
-    {
-        "label": "basket",
-        "confidence score": 0.38,
-        "box": [
-            251,
-            2,
-            468,
-            216
-        ],
-        "saved_image_path": "detected_objects/baseball_basket_4.png"
-    }
-]
-Detected Objects:
-Detected baseball with confidence 0.73
-Bounding box: [614, 137, 671, 191]
-Saved image (with padding): detected_objects/baseball_baseball_1.png
-
-Detected baseball with confidence 0.73
-Bounding box: [114, 377, 171, 431]
-Saved image (with padding): detected_objects/baseball_baseball_2.png
-
-Detected baseball with confidence 0.72
-Bounding box: [632, 67, 689, 126]
-Saved image (with padding): detected_objects/baseball_baseball_3.png
-
-Detected baseball with confidence 0.72
-Bounding box: [132, 67, 189, 126]
-Saved image (with padding): detected_objects/baseball_baseball_4.png
-
-Detected baseball with confidence 0.71
-Bounding box: [382, 67, 439, 126]
-Saved image (with padding): detected_objects/baseball_baseball_5.png
-
-Detected baseball with confidence 0.71
-Bounding box: [364, 137, 421, 191]
-Saved image (with padding): detected_objects/baseball_baseball_6.png
-
-Detected baseball with confidence 0.71
-Bounding box: [132, 307, 189, 366]
-Saved image (with padding): detected_objects/baseball_baseball_7.png
-
-Detected baseball with confidence 0.71
-Bounding box: [114, 136, 171, 191]
-Saved image (with padding): detected_objects/baseball_baseball_8.png
-
-Detected baseball with confidence 0.7
-Bounding box: [57, 49, 115, 107]
-Saved image (with padding): detected_objects/baseball_baseball_9.png
-
-Detected baseball with confidence 0.69
-Bounding box: [307, 49, 365, 106]
-Saved image (with padding): detected_objects/baseball_baseball_10.png
-
-Detected baseball with confidence 0.68
-Bounding box: [57, 289, 115, 346]
-Saved image (with padding): detected_objects/baseball_baseball_11.png
-
-Detected baseball with confidence 0.68
-Bounding box: [86, 335, 143, 393]
-Saved image (with padding): detected_objects/baseball_baseball_12.png
-
-Detected baseball with confidence 0.68
-Bounding box: [557, 49, 615, 107]
-Saved image (with padding): detected_objects/baseball_baseball_13.png
-
-Detected baseball with confidence 0.68
-Bounding box: [35, 352, 92, 410]
-Saved image (with padding): detected_objects/baseball_baseball_14.png
-
-Detected baseball with confidence 0.68
-Bounding box: [86, 95, 143, 153]
-Saved image (with padding): detected_objects/baseball_baseball_15.png
-
-Detected baseball with confidence 0.67
-Bounding box: [586, 95, 643, 153]
-Saved image (with padding): detected_objects/baseball_baseball_16.png
-
-Detected baseball with confidence 0.66
-Bounding box: [285, 111, 342, 169]
-Saved image (with padding): detected_objects/baseball_baseball_17.png
-
-Detected baseball with confidence 0.66
-Bounding box: [35, 111, 91, 170]
-Saved image (with padding): detected_objects/baseball_baseball_18.png
-
-Detected baseball with confidence 0.66
-Bounding box: [535, 111, 592, 169]
-Saved image (with padding): detected_objects/baseball_baseball_19.png
-
-Detected baseball with confidence 0.66
-Bounding box: [337, 95, 393, 153]
-Saved image (with padding): detected_objects/baseball_baseball_20.png
-
-Detected basket with confidence 0.41
-Bounding box: [1, 2, 218, 216]
-Saved image (with padding): detected_objects/baseball_basket_1.png
-
-Detected basket with confidence 0.39
-Bounding box: [501, 2, 718, 216]
-Saved image (with padding): detected_objects/baseball_basket_2.png
-
-Detected basket with confidence 0.38
-Bounding box: [2, 242, 218, 456]
-Saved image (with padding): detected_objects/baseball_basket_3.png
-
-Detected basket with confidence 0.38
-Bounding box: [251, 2, 468, 216]
-Saved image (with padding): detected_objects/baseball_basket_4.png
-
-Done!

octotools/tools/advanced_object_detector/tool.py

@@ -1,236 +0,0 @@
-# Grounding DINO Object Detection Tool
-# https://huggingface.co/IDEA-Research/grounding-dino
-
-import os
-import time
-
-from octotools.tools.base import BaseTool
-from PIL import Image, ImageOps
-
-import os
-# Suppress stderr by redirecting it to /dev/null
-import sys
-import re
-import base64
-import requests
-sys.stderr = open(os.devnull, 'w')
-
-
-class Advanced_Object_Detector_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="Advanced_Object_Detector_Tool",
-            tool_description="A tool that detects objects in an image using the Grounding DINO-X model and saves individual object images with empty padding.",
-            tool_version="1.0.0",
-            input_types={
-                "image": "str - The path to the image file.",
-                "labels": "list - A list of object labels to detect.",
-                "threshold": "float - The confidence threshold for detection (default: 0.35).",
-                "padding": "int - The number of pixels to add as empty padding around detected objects (default: 20)."
-            },
-            output_type="list - A list of detected objects with their scores, bounding boxes, and saved image paths.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png", labels=["baseball", "basket"])',
-                    "description": "Detect baseball and basket in an image, save the detected objects with default empty padding, and return their paths."
-                },
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png", labels=["car", "person"], threshold=0.5, model_size="base", padding=15)',
-                    "description": "Detect car and person in an image using the base model, save the detected objects with 15 pixels of empty padding, and return their paths."
-                }
-            ],
-            user_metadata={
-                "limitation": "The model may not always detect objects accurately, and its performance can vary depending on the input image and the associated labels. It typically struggles with detecting small objects, objects that are uncommon, or objects with limited or specific attributes. For improved accuracy or better detection in certain situations, consider using supplementary tools or image processing techniques to provide additional information for verification."
-            }
-        )
-        self.DINO_KEY = os.environ.get("DINO_KEY")
-
-    def preprocess_caption(self, caption):
-        result = caption.lower().strip()
-        if result.endswith("."):
-            return result
-        return result + "."
-
-    def build_tool(self, threshold=0.35):
-
-        params_dict = {
-                        'headers': {
-                                    "Content-Type": "application/json",
-                                    "Token"       : self.DINO_KEY
-                                    },
-                        'body':{
-                                    "image"  : None,
-                                    "prompts": [
-                                        {"type": "text", "text": None},
-                                    ],
-                                    "bbox_threshold": threshold 
-                                }
-
-                      }
-        return params_dict
-
-
-    def save_detected_object(self, image, box, image_name, label, index, padding):
-        object_image = image.crop(box)
-        padded_image = ImageOps.expand(object_image, border=padding, fill='white')
-        
-        filename = f"{image_name}_{label}_{index}.png"
-        os.makedirs(self.output_dir, exist_ok=True)
-        save_path = os.path.join(self.output_dir, filename)
-        
-        padded_image.save(save_path)
-        return save_path
-
-    def execute(self, image, labels, threshold=0.35, padding=20, max_retries=10, retry_delay=5):
-        retry_count = 0
-        params = self.build_tool(threshold)
-
-        def process_image(input_str):
-
-            def image_to_base64(image_path):
-                with open(image_path, "rb") as image_file:
-                    return base64.b64encode(image_file.read()).decode('utf-8')
-            # Define common image file extensions
-            image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg', '.tiff', '.webp'}
-
-            # Check if it is a URL
-            url_pattern = re.compile(r'^(http|https|ftp)://')
-            if url_pattern.match(input_str):
-                if input_str.lower().endswith(tuple(image_extensions)):
-                    return input_str
-                return input_str
-
-            # Check if it is a file path
-            _, ext = os.path.splitext(input_str)
-            if ext.lower() in image_extensions:
-                image_base64 = image_to_base64(input_str)
-                return f'data:image/png;base64,{image_base64}'
-            return None
-
-        if len(labels) < 1:
-            preprocessed_prompt = '<prompt_free>'
-        else:
-            preprocessed_prompt = ''
-            for label in labels:
-                preprocessed_prompt += self.preprocess_caption(label)
-
-
-        body = params['body']
-        body['image'] = process_image(image)
-        body['prompts'] =  [{"type": "text", "text": preprocessed_prompt}]
-
-        # send request
-        resp = requests.post(
-            'https://api.deepdataspace.com/tasks/dinox',
-            json=body,
-            headers=params['headers']
-        )
-
-        if resp.status_code == 200:
-            json_resp = resp.json()
-            print(json_resp)
-
-            # get task_uuid
-            task_uuid = json_resp["data"]["task_uuid"]
-            print(f'task_uuid:{task_uuid}')
-
-            # poll get task result
-            while retry_count < max_retries:
-                resp = requests.get(f'https://api.deepdataspace.com/task_statuses/{task_uuid}', headers=params['headers'])
-                
-
-                if resp.status_code != 200:
-                    break
-                json_resp = resp.json()
-
-                if json_resp["data"]["status"] not in ["waiting", "running"]:
-                    break
-                time.sleep(1)#retry_delay)
-                retry_count += 1
-
-            if json_resp["data"]["status"] == "failed":
-                print(f'failed resp: {json_resp}')
-            elif json_resp["data"]["status"] == "success":
-                # print(f'success resp: {json_resp}')
-                formatted_results = []
-                original_image = Image.open(image)
-                image_name = os.path.splitext(os.path.basename(image))[0]
-                
-                object_counts = {}
-
-                for result in json_resp['data']['result']['objects']:
-                    box = tuple(result["bbox"])
-                    try:
-                        box = [int(x) for x in box]
-                    except:
-                        continue
-                    label = result["category"]
-                    score = round(result["score"], 2)
-                    if label.endswith("."):
-                        label = label[:-1]
-                    
-                    object_counts[label] = object_counts.get(label, 0) + 1
-                    index = object_counts[label]
-
-                    save_path = self.save_detected_object(original_image, box, image_name, label, index, padding)
-            
-                    formatted_results.append({
-                        "label": label,
-                        "confidence score": score,
-                        "box": box,
-                        "saved_image_path": save_path
-                    })
-
-                return formatted_results
-            else:
-                print(f'get task resp: {resp.status_code} - {resp.text}')
-        else:
-            print(f'Error: {resp.status_code} - {resp.text}')
-        
-        print(f"Failed to detect objects after {max_retries} attempts.")
-        return []
-
-    def get_metadata(self):
-        metadata = super().get_metadata()
-        return metadata
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools/tools/advanced_object_detector
-    python tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the Object_Detector_Tool
-    tool = Advanced_Object_Detector_Tool()
-    tool.set_custom_output_dir("detected_objects")
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    # print(metadata)
-
-    # Construct the full path to the image using the script's directory
-    relative_image_path = "examples/baseball.png"
-    image_path = os.path.join(script_dir, relative_image_path)
-
-    import json
-
-    # Execute the tool
-    try:
-        execution = tool.execute(image=image_path, labels=["baseball", "basket"], padding=20)
-        print(json.dumps(execution, indent=4))
-        print("Detected Objects:")
-        for obj in execution:
-            print(f"Detected {obj['label']} with confidence {obj['confidence score']}")
-            print(f"Bounding box: {obj['box']}")
-            print(f"Saved image (with padding): {obj['saved_image_path']}")
-            print()
-    except ValueError as e: 
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/arxiv_paper_searcher/test.log

@@ -1,120 +0,0 @@
-ArXiv Search Tool Test
-Tool Metadata:
-{'tool_name': 'ArXiv_Paper_Searcher_Tool', 'tool_description': 'A tool that searches arXiv for papers based on a given query.', 'tool_version': '1.0.0', 'input_types': {'query': 'str - The search query for arXiv papers.', 'size': 'int - The number of results per page (25, 50, 100, or 200). If None, use 25.', 'max_results': 'int - The maximum number of papers to return (default: 25). Should be less than or equal to 100.'}, 'output_type': 'list - A list of dictionaries containing paper information.', 'demo_commands': [{'command': 'execution = tool.execute(query="tool agents with large language models")', 'description': 'Search for papers about tool agents with large language models.'}, {'command': 'execution = tool.execute(query="quantum computing", size=100, max_results=50)', 'description': 'Search for quantum computing papers, with 100 results per page, returning a maximum of 50 papers.'}, {'command': 'execution = tool.execute(query="machine learning", max_results=75)', 'description': 'Search for machine learning papers, returning a maximum of 75 papers.'}], 'require_llm_engine': False, 'user_metadata': {'valid_sizes': [25, 50, 100, 200], 'base_url': 'https://arxiv.org/search/'}}
-
-==>> Execution:
-[
-    {
-        "title": "Position: Multimodal Large Language Models Can Significantly Advance Scientific Reasoning",
-        "authors": "Yibo Yan, Shen Wang, Jiahao Huo, Jingheng Ye, Zhendong Chu, Xuming Hu, Philip S. Yu, Carla Gomes, Bart Selman, Qingsong Wen",
-        "abstract": "Scientific reasoning, the process through which humans apply logic, evidence, and critical thinking to explore and interpret scientific phenomena, is essential in advancing knowledge reasoning across diverse fields. However, despite significant progress, current scientific reasoning models still struggle with generalization across domains and often fall short of multimodal perception. Multimodal Large Language Models (MLLMs), which integrate text, images, and other modalities, present an exciting opportunity to overcome these limitations and enhance scientific reasoning. Therefore, this position paper argues that MLLMs can significantly advance scientific reasoning across disciplines such as mathematics, physics, chemistry, and biology. First, we propose a four-stage research roadmap of scientific reasoning capabilities, and highlight the current state of MLLM applications in scientific reasoning, noting their ability to integrate and reason over diverse data types. Second, we summarize the key challenges that remain obstacles to achieving MLLM's full potential. To address these challenges, we propose actionable insights and suggestions for the future. Overall, our work offers a novel perspective on MLLM integration with scientific reasoning, providing the LLM community with a valuable vision for achieving Artificial General Intelligence (AGI).",
-        "link": "https://arxiv.org/abs/2502.02871"
-    },
-    {
-        "title": "Adaptive Graph of Thoughts: Test-Time Adaptive Reasoning Unifying Chain, Tree, and Graph Structures",
-        "authors": "Tushar Pandey, Ara Ghukasyan, Oktay Goktas, Santosh Kumar Radha",
-        "abstract": "Large Language Models (LLMs) have demonstrated impressive reasoning capabilities, yet their performance is highly dependent on the prompting strategy and model scale. While reinforcement learning and fine-tuning have been deployed to boost reasoning, these approaches incur substantial computational and data overhead. In this work, we introduce Adaptive Graph of Thoughts (AGoT), a dynamic, graph-based inference framework that enhances LLM reasoning solely at test time. Rather than relying on fixed-step methods like Chain of Thought (CoT) or Tree of Thoughts (ToT), AGoT recursively decomposes complex queries into structured subproblems, forming an dynamic directed acyclic graph (DAG) of interdependent reasoning steps. By selectively expanding only those subproblems that require further analysis, AGoT unifies the strengths of chain, tree, and graph paradigms into a cohesive framework that allocates computation where it is most needed. We validate our approach on diverse benchmarks spanning multi-hop retrieval, scientific reasoning, and mathematical problem-solving, achieving up to 46.2% improvement on scientific reasoning tasks (GPQA) - comparable to gains achieved through computationally intensive reinforcement learning approaches and outperforming state-of-the-art iterative approaches. These results suggest that dynamic decomposition and structured recursion offer a scalable, cost-effective alternative to post-training modifications, paving the way for more robust, general-purpose reasoning in LLMs.",
-        "link": "https://arxiv.org/abs/2502.05078"
-    },
-    {
-        "title": "VersaPRM: Multi-Domain Process Reward Model via Synthetic Reasoning Data",
-        "authors": "Thomas Zeng, Shuibai Zhang, Shutong Wu, Christian Classen, Daewon Chae, Ethan Ewer, Minjae Lee, Heeju Kim, Wonjun Kang, Jackson Kunde, Ying Fan, Jungtaek Kim, Hyung Il Koo, Kannan Ramchandran, Dimitris Papailiopoulos, Kangwook Lee",
-        "abstract": "Process Reward Models (PRMs) have proven effective at enhancing mathematical reasoning for Large Language Models (LLMs) by leveraging increased inference-time computation. However, they are predominantly trained on mathematical data and their generalizability to non-mathematical domains has not been rigorously studied. In response, this work first shows that current PRMs have poor performance in other domains. To address this limitation, we introduce VersaPRM, a multi-domain PRM trained on synthetic reasoning data generated using our novel data generation and annotation method. VersaPRM achieves consistent performance gains across diverse domains. For instance, in the MMLU-Pro category of Law, VersaPRM via weighted majority voting, achieves a 7.9% performance gain over the majority voting baseline -- surpassing Qwen2.5-Math-PRM's gain of 1.3%. We further contribute to the community by open-sourcing all data, code and models for VersaPRM.",
-        "link": "https://arxiv.org/abs/2502.06737"
-    },
-    {
-        "title": "Large Language Models for Multi-Robot Systems: A Survey",
-        "authors": "Peihan Li, Zijian An, Shams Abrar, Lifeng Zhou",
-        "abstract": "The rapid advancement of Large Language Models (LLMs) has opened new possibilities in Multi-Robot Systems (MRS), enabling enhanced communication, task planning, and human-robot interaction. Unlike traditional single-robot and multi-agent systems, MRS poses unique challenges, including coordination, scalability, and real-world adaptability. This survey provides the first comprehensive exploration of LLM integration into MRS. It systematically categorizes their applications across high-level task allocation, mid-level motion planning, low-level action generation, and human intervention. We highlight key applications in diverse domains, such as household robotics, construction, formation control, target tracking, and robot games, showcasing the versatility and transformative potential of LLMs in MRS. Furthermore, we examine the challenges that limit adapting LLMs in MRS, including mathematical reasoning limitations, hallucination, latency issues, and the need for robust benchmarking systems. Finally, we outline opportunities for future research, emphasizing advancements in fine-tuning, reasoning techniques, and task-specific models. This survey aims to guide researchers in the intelligence and real-world deployment of MRS powered by LLMs. Based on the fast-evolving nature of research in the field, we keep updating the papers in the open-source Github repository.",
-        "link": "https://arxiv.org/abs/2502.03814"
-    },
-    {
-        "title": "MergeME: Model Merging Techniques for Homogeneous and Heterogeneous MoEs",
-        "authors": "Yuhang Zhou, Giannis Karamanolakis, Victor Soto, Anna Rumshisky, Mayank Kulkarni, Furong Huang, Wei Ai, Jianhua Lu",
-        "abstract": "The recent success of specialized Large Language Models (LLMs) in domains such as mathematical reasoning and coding has led to growing interest in methods for merging these expert LLMs into a unified Mixture-of-Experts (MoE) model, with the goal of enhancing performance in each domain while retaining effectiveness on general tasks. However, the effective merging of expert models remains an open challenge, especially for models with highly divergent weight parameters or different architectures. State-of-the-art MoE merging methods only work with homogeneous model architectures and rely on simple unweighted averaging to merge expert layers, which does not address parameter interference and requires extensive fine-tuning of the merged MoE to restore performance. To address these limitations, this paper introduces new MoE merging techniques, including strategies to mitigate parameter interference, routing heuristics to reduce the need for MoE fine-tuning, and a novel method for merging experts with different architectures. Extensive experiments across multiple domains demonstrate the effectiveness of our proposed methods, reducing fine-tuning costs, improving performance over state-of-the-art methods, and expanding the applicability of MoE merging.",
-        "link": "https://arxiv.org/abs/2502.00997"
-    },
-    {
-        "title": "Satori: Reinforcement Learning with Chain-of-Action-Thought Enhances LLM Reasoning via Autoregressive Search",
-        "authors": "Maohao Shen, Guangtao Zeng, Zhenting Qi, Zhang-Wei Hong, Zhenfang Chen, Wei Lu, Gregory Wornell, Subhro Das, David Cox, Chuang Gan",
-        "abstract": "Large language models (LLMs) have demonstrated remarkable reasoning capabilities across diverse domains. Recent studies have shown that increasing test-time computation enhances LLMs' reasoning capabilities. This typically involves extensive sampling at inference time guided by an external LLM verifier, resulting in a two-player system. Despite external guidance, the effectiveness of this system demonstrates the potential of a single LLM to tackle complex tasks. Thus, we pose a new research problem: Can we internalize the searching capabilities to fundamentally enhance the reasoning abilities of a single LLM? This work explores an orthogonal direction focusing on post-training LLMs for autoregressive searching (i.e., an extended reasoning process with self-reflection and self-exploration of new strategies). To achieve this, we propose the Chain-of-Action-Thought (COAT) reasoning and a two-stage training paradigm: 1) a small-scale format tuning stage to internalize the COAT reasoning format and 2) a large-scale self-improvement stage leveraging reinforcement learning. Our approach results in Satori, a 7B LLM trained on open-source models and data. Extensive empirical evaluations demonstrate that Satori achieves state-of-the-art performance on mathematical reasoning benchmarks while exhibits strong generalization to out-of-domain tasks. Code, data, and models will be fully open-sourced.",
-        "link": "https://arxiv.org/abs/2502.02508"
-    },
-    {
-        "title": "Reasoning-as-Logic-Units: Scaling Test-Time Reasoning in Large Language Models Through Logic Unit Alignment",
-        "authors": "Cheryl Li, Tianyuan Xu, Yiwen Guo",
-        "abstract": "Chain-of-Thought (CoT) prompting has shown promise in enhancing the reasoning capabilities of large language models (LLMs) by generating natural language (NL) rationales that lead to the final answer. However, it struggles with numerical computation, which has somehow led to the development of program-aided techniques. Despite their potential, a persistent challenge remains: inconsistencies between LLM-reported reasoning steps and the logic in generated programs, which we term ``reasoning hallucinations.\" This stems from the inherent ambiguities of NL and the statistical nature of LLMs, which often lack rigorous logical coherence. To address this challenge, we propose a novel test-time scaling framework, Reasoning-as-Logic-Units (RaLU), which constructs a more reliable reasoning path by aligning logical units between the generated program and their corresponding NL descriptions. By decomposing the initially generated program into discrete units using static analysis, RaLU engages in an iterative dialogue with the LLM to judge, refine, and explain each unit. A rewind-and-correct mechanism ensures alignment between code statements and task requirements in each unit, ultimately forming a cohesive reasoning path under the program's logic, from which the model reaches a final solution. Our experiments demonstrate that RaLU significantly outperforms existing baselines in mathematical reasoning (GSM8K, MATH) and algorithmic reasoning (HumanEval+, MBPP+), underscoring its potential to advance LLM reasoning and programming by offering enhanced accuracy and interpretability.",
-        "link": "https://arxiv.org/abs/2502.07803"
-    },
-    {
-        "title": "Premise-Augmented Reasoning Chains Improve Error Identification in Math reasoning with LLMs",
-        "authors": "Sagnik Mukherjee, Abhinav Chinta, Takyoung Kim, Tarun Anoop Sharma, Dilek Hakkani-T\u00fcr",
-        "abstract": "Chain-of-Thought (CoT) prompting enhances mathematical reasoning in large language models (LLMs) by enabling detailed step-by-step solutions. However, due to the verbosity of LLMs, the resulting reasoning chains can be long, making it harder to verify the reasoning steps and trace issues resulting from dependencies between the steps that may be farther away in the sequence of steps. Importantly, mathematical reasoning allows each step to be derived from a small set of premises, which are a subset of the preceding steps in the reasoning chain. In this paper, we present a framework that identifies the premises for each step, to improve the evaluation of reasoning. We restructure conventional linear reasoning chains into Premise Augmented Reasoning Chains (PARC) by introducing premise links, resulting in a directed acyclic graph where the nodes are the steps and the edges are the premise links. Through experiments with a PARC-based dataset that we built, namely PERL (Premises and ERrors identification in LLMs), we demonstrate that LLMs can reliably identify premises within complex reasoning chains. In particular, even open-source LLMs achieve 90% recall in premise identification. We also show that PARC helps to identify errors in reasoning chains more reliably. The accuracy of error identification improves by 6% to 16% absolute when step-by-step verification is carried out in PARC under the premises. Our findings highlight the utility of premise-centric representations in addressing complex problem-solving tasks and open new avenues for improving the reliability of LLM-based reasoning evaluations.",
-        "link": "https://arxiv.org/abs/2502.02362"
-    },
-    {
-        "title": "Advanced Weakly-Supervised Formula Exploration for Neuro-Symbolic Mathematical Reasoning",
-        "authors": "Yuxuan Wu, Hideki Nakayama",
-        "abstract": "In recent years, neuro-symbolic methods have become a popular and powerful approach that augments artificial intelligence systems with the capability to perform abstract, logical, and quantitative deductions with enhanced precision and controllability. Recent studies successfully performed symbolic reasoning by leveraging various machine learning models to explicitly or implicitly predict intermediate labels that provide symbolic instructions. However, these intermediate labels are not always prepared for every task as a part of training data, and pre-trained models, represented by Large Language Models (LLMs), also do not consistently generate valid symbolic instructions with their intrinsic knowledge. On the other hand, existing work developed alternative learning techniques that allow the learning system to autonomously uncover optimal symbolic instructions. Nevertheless, their performance also exhibits limitations when faced with relatively huge search spaces or more challenging reasoning problems. In view of this, in this work, we put forward an advanced practice for neuro-symbolic reasoning systems to explore the intermediate labels with weak supervision from problem inputs and final outputs. Our experiments on the Mathematics dataset illustrated the effectiveness of our proposals from multiple aspects.",
-        "link": "https://arxiv.org/abs/2502.00629"
-    },
-    {
-        "title": "ARIES: Stimulating Self-Refinement of Large Language Models by Iterative Preference Optimization",
-        "authors": "Yongcheng Zeng, Xinyu Cui, Xuanfa Jin, Guoqing Liu, Zexu Sun, Quan He, Dong Li, Ning Yang, Jianye Hao, Haifeng Zhang, Jun Wang",
-        "abstract": "A truly intelligent Large Language Model (LLM) should be capable of correcting errors in its responses through external interactions. However, even the most advanced models often face challenges in improving their outputs. In this paper, we explore how to cultivate LLMs with the self-refinement capability through iterative preference training, and how this ability can be leveraged to improve model performance during inference. To this end, we introduce a novel post-training and inference framework, called ARIES: Adaptive Refinement and Iterative Enhancement Structure. This method iteratively performs preference training and self-refinement-based data collection. During training, ARIES strengthen the model's direct question-answering capability while simultaneously unlocking its self-refinement potential. During inference, ARIES harnesses this self-refinement capability to generate a series of progressively refined responses, which are then filtered using either the Reward Model Scoring or a simple yet effective Rule-Based Selection mechanism, specifically tailored to our approach, to construct a dataset for the next round of preference training. Experimental results demonstrate the remarkable performance of ARIES. When applied to the Llama-3.1-8B model and under the self-refinement setting, ARIES surpasses powerful models such as GPT-4o, achieving 62.3% length-controlled (LC) and a 63.3% raw win rates on AlpacaEval 2, outperforming Iterative DPO by 27.8% and 35.5% respectively, as well as a 50.3% win rate on Arena-Hard, surpassing Iterative DPO by 26.6%. Furthermore, ARIES consistently enhances performance on mathematical reasoning tasks like GSM8K and MATH.",
-        "link": "https://arxiv.org/abs/2502.05605"
-    }
-]
-
-==>> Search Results:
-1. Position: Multimodal Large Language Models Can Significantly Advance Scientific Reasoning
-   Authors: Yibo Yan, Shen Wang, Jiahao Huo, Jingheng Ye, Zhendong Chu, Xuming Hu, Philip S. Yu, Carla Gomes, Bart Selman, Qingsong Wen
-   Abstract: Scientific reasoning, the process through which humans apply logic, evidence, and critical thinking to explore and interpret scientific phenomena, is essential in advancing knowledge reasoning across diverse fields. However, despite significant progress, current scientific reasoning models still struggle with generalization across domains and often fall short of multimodal perception. Multimodal Large Language Models (MLLMs), which integrate text, images, and other modalities, present an exciting opportunity to overcome these limitations and enhance scientific reasoning. Therefore, this position paper argues that MLLMs can significantly advance scientific reasoning across disciplines such as mathematics, physics, chemistry, and biology. First, we propose a four-stage research roadmap of scientific reasoning capabilities, and highlight the current state of MLLM applications in scientific reasoning, noting their ability to integrate and reason over diverse data types. Second, we summarize the key challenges that remain obstacles to achieving MLLM's full potential. To address these challenges, we propose actionable insights and suggestions for the future. Overall, our work offers a novel perspective on MLLM integration with scientific reasoning, providing the LLM community with a valuable vision for achieving Artificial General Intelligence (AGI).
-   Link: https://arxiv.org/abs/2502.02871
-
-2. Adaptive Graph of Thoughts: Test-Time Adaptive Reasoning Unifying Chain, Tree, and Graph Structures
-   Authors: Tushar Pandey, Ara Ghukasyan, Oktay Goktas, Santosh Kumar Radha
-   Abstract: Large Language Models (LLMs) have demonstrated impressive reasoning capabilities, yet their performance is highly dependent on the prompting strategy and model scale. While reinforcement learning and fine-tuning have been deployed to boost reasoning, these approaches incur substantial computational and data overhead. In this work, we introduce Adaptive Graph of Thoughts (AGoT), a dynamic, graph-based inference framework that enhances LLM reasoning solely at test time. Rather than relying on fixed-step methods like Chain of Thought (CoT) or Tree of Thoughts (ToT), AGoT recursively decomposes complex queries into structured subproblems, forming an dynamic directed acyclic graph (DAG) of interdependent reasoning steps. By selectively expanding only those subproblems that require further analysis, AGoT unifies the strengths of chain, tree, and graph paradigms into a cohesive framework that allocates computation where it is most needed. We validate our approach on diverse benchmarks spanning multi-hop retrieval, scientific reasoning, and mathematical problem-solving, achieving up to 46.2% improvement on scientific reasoning tasks (GPQA) - comparable to gains achieved through computationally intensive reinforcement learning approaches and outperforming state-of-the-art iterative approaches. These results suggest that dynamic decomposition and structured recursion offer a scalable, cost-effective alternative to post-training modifications, paving the way for more robust, general-purpose reasoning in LLMs.
-   Link: https://arxiv.org/abs/2502.05078
-
-3. VersaPRM: Multi-Domain Process Reward Model via Synthetic Reasoning Data
-   Authors: Thomas Zeng, Shuibai Zhang, Shutong Wu, Christian Classen, Daewon Chae, Ethan Ewer, Minjae Lee, Heeju Kim, Wonjun Kang, Jackson Kunde, Ying Fan, Jungtaek Kim, Hyung Il Koo, Kannan Ramchandran, Dimitris Papailiopoulos, Kangwook Lee
-   Abstract: Process Reward Models (PRMs) have proven effective at enhancing mathematical reasoning for Large Language Models (LLMs) by leveraging increased inference-time computation. However, they are predominantly trained on mathematical data and their generalizability to non-mathematical domains has not been rigorously studied. In response, this work first shows that current PRMs have poor performance in other domains. To address this limitation, we introduce VersaPRM, a multi-domain PRM trained on synthetic reasoning data generated using our novel data generation and annotation method. VersaPRM achieves consistent performance gains across diverse domains. For instance, in the MMLU-Pro category of Law, VersaPRM via weighted majority voting, achieves a 7.9% performance gain over the majority voting baseline -- surpassing Qwen2.5-Math-PRM's gain of 1.3%. We further contribute to the community by open-sourcing all data, code and models for VersaPRM.
-   Link: https://arxiv.org/abs/2502.06737
-
-4. Large Language Models for Multi-Robot Systems: A Survey
-   Authors: Peihan Li, Zijian An, Shams Abrar, Lifeng Zhou
-   Abstract: The rapid advancement of Large Language Models (LLMs) has opened new possibilities in Multi-Robot Systems (MRS), enabling enhanced communication, task planning, and human-robot interaction. Unlike traditional single-robot and multi-agent systems, MRS poses unique challenges, including coordination, scalability, and real-world adaptability. This survey provides the first comprehensive exploration of LLM integration into MRS. It systematically categorizes their applications across high-level task allocation, mid-level motion planning, low-level action generation, and human intervention. We highlight key applications in diverse domains, such as household robotics, construction, formation control, target tracking, and robot games, showcasing the versatility and transformative potential of LLMs in MRS. Furthermore, we examine the challenges that limit adapting LLMs in MRS, including mathematical reasoning limitations, hallucination, latency issues, and the need for robust benchmarking systems. Finally, we outline opportunities for future research, emphasizing advancements in fine-tuning, reasoning techniques, and task-specific models. This survey aims to guide researchers in the intelligence and real-world deployment of MRS powered by LLMs. Based on the fast-evolving nature of research in the field, we keep updating the papers in the open-source Github repository.
-   Link: https://arxiv.org/abs/2502.03814
-
-5. MergeME: Model Merging Techniques for Homogeneous and Heterogeneous MoEs
-   Authors: Yuhang Zhou, Giannis Karamanolakis, Victor Soto, Anna Rumshisky, Mayank Kulkarni, Furong Huang, Wei Ai, Jianhua Lu
-   Abstract: The recent success of specialized Large Language Models (LLMs) in domains such as mathematical reasoning and coding has led to growing interest in methods for merging these expert LLMs into a unified Mixture-of-Experts (MoE) model, with the goal of enhancing performance in each domain while retaining effectiveness on general tasks. However, the effective merging of expert models remains an open challenge, especially for models with highly divergent weight parameters or different architectures. State-of-the-art MoE merging methods only work with homogeneous model architectures and rely on simple unweighted averaging to merge expert layers, which does not address parameter interference and requires extensive fine-tuning of the merged MoE to restore performance. To address these limitations, this paper introduces new MoE merging techniques, including strategies to mitigate parameter interference, routing heuristics to reduce the need for MoE fine-tuning, and a novel method for merging experts with different architectures. Extensive experiments across multiple domains demonstrate the effectiveness of our proposed methods, reducing fine-tuning costs, improving performance over state-of-the-art methods, and expanding the applicability of MoE merging.
-   Link: https://arxiv.org/abs/2502.00997
-
-6. Satori: Reinforcement Learning with Chain-of-Action-Thought Enhances LLM Reasoning via Autoregressive Search
-   Authors: Maohao Shen, Guangtao Zeng, Zhenting Qi, Zhang-Wei Hong, Zhenfang Chen, Wei Lu, Gregory Wornell, Subhro Das, David Cox, Chuang Gan
-   Abstract: Large language models (LLMs) have demonstrated remarkable reasoning capabilities across diverse domains. Recent studies have shown that increasing test-time computation enhances LLMs' reasoning capabilities. This typically involves extensive sampling at inference time guided by an external LLM verifier, resulting in a two-player system. Despite external guidance, the effectiveness of this system demonstrates the potential of a single LLM to tackle complex tasks. Thus, we pose a new research problem: Can we internalize the searching capabilities to fundamentally enhance the reasoning abilities of a single LLM? This work explores an orthogonal direction focusing on post-training LLMs for autoregressive searching (i.e., an extended reasoning process with self-reflection and self-exploration of new strategies). To achieve this, we propose the Chain-of-Action-Thought (COAT) reasoning and a two-stage training paradigm: 1) a small-scale format tuning stage to internalize the COAT reasoning format and 2) a large-scale self-improvement stage leveraging reinforcement learning. Our approach results in Satori, a 7B LLM trained on open-source models and data. Extensive empirical evaluations demonstrate that Satori achieves state-of-the-art performance on mathematical reasoning benchmarks while exhibits strong generalization to out-of-domain tasks. Code, data, and models will be fully open-sourced.
-   Link: https://arxiv.org/abs/2502.02508
-
-7. Reasoning-as-Logic-Units: Scaling Test-Time Reasoning in Large Language Models Through Logic Unit Alignment
-   Authors: Cheryl Li, Tianyuan Xu, Yiwen Guo
-   Abstract: Chain-of-Thought (CoT) prompting has shown promise in enhancing the reasoning capabilities of large language models (LLMs) by generating natural language (NL) rationales that lead to the final answer. However, it struggles with numerical computation, which has somehow led to the development of program-aided techniques. Despite their potential, a persistent challenge remains: inconsistencies between LLM-reported reasoning steps and the logic in generated programs, which we term ``reasoning hallucinations." This stems from the inherent ambiguities of NL and the statistical nature of LLMs, which often lack rigorous logical coherence. To address this challenge, we propose a novel test-time scaling framework, Reasoning-as-Logic-Units (RaLU), which constructs a more reliable reasoning path by aligning logical units between the generated program and their corresponding NL descriptions. By decomposing the initially generated program into discrete units using static analysis, RaLU engages in an iterative dialogue with the LLM to judge, refine, and explain each unit. A rewind-and-correct mechanism ensures alignment between code statements and task requirements in each unit, ultimately forming a cohesive reasoning path under the program's logic, from which the model reaches a final solution. Our experiments demonstrate that RaLU significantly outperforms existing baselines in mathematical reasoning (GSM8K, MATH) and algorithmic reasoning (HumanEval+, MBPP+), underscoring its potential to advance LLM reasoning and programming by offering enhanced accuracy and interpretability.
-   Link: https://arxiv.org/abs/2502.07803
-
-8. Premise-Augmented Reasoning Chains Improve Error Identification in Math reasoning with LLMs
-   Authors: Sagnik Mukherjee, Abhinav Chinta, Takyoung Kim, Tarun Anoop Sharma, Dilek Hakkani-Tür
-   Abstract: Chain-of-Thought (CoT) prompting enhances mathematical reasoning in large language models (LLMs) by enabling detailed step-by-step solutions. However, due to the verbosity of LLMs, the resulting reasoning chains can be long, making it harder to verify the reasoning steps and trace issues resulting from dependencies between the steps that may be farther away in the sequence of steps. Importantly, mathematical reasoning allows each step to be derived from a small set of premises, which are a subset of the preceding steps in the reasoning chain. In this paper, we present a framework that identifies the premises for each step, to improve the evaluation of reasoning. We restructure conventional linear reasoning chains into Premise Augmented Reasoning Chains (PARC) by introducing premise links, resulting in a directed acyclic graph where the nodes are the steps and the edges are the premise links. Through experiments with a PARC-based dataset that we built, namely PERL (Premises and ERrors identification in LLMs), we demonstrate that LLMs can reliably identify premises within complex reasoning chains. In particular, even open-source LLMs achieve 90% recall in premise identification. We also show that PARC helps to identify errors in reasoning chains more reliably. The accuracy of error identification improves by 6% to 16% absolute when step-by-step verification is carried out in PARC under the premises. Our findings highlight the utility of premise-centric representations in addressing complex problem-solving tasks and open new avenues for improving the reliability of LLM-based reasoning evaluations.
-   Link: https://arxiv.org/abs/2502.02362
-
-9. Advanced Weakly-Supervised Formula Exploration for Neuro-Symbolic Mathematical Reasoning
-   Authors: Yuxuan Wu, Hideki Nakayama
-   Abstract: In recent years, neuro-symbolic methods have become a popular and powerful approach that augments artificial intelligence systems with the capability to perform abstract, logical, and quantitative deductions with enhanced precision and controllability. Recent studies successfully performed symbolic reasoning by leveraging various machine learning models to explicitly or implicitly predict intermediate labels that provide symbolic instructions. However, these intermediate labels are not always prepared for every task as a part of training data, and pre-trained models, represented by Large Language Models (LLMs), also do not consistently generate valid symbolic instructions with their intrinsic knowledge. On the other hand, existing work developed alternative learning techniques that allow the learning system to autonomously uncover optimal symbolic instructions. Nevertheless, their performance also exhibits limitations when faced with relatively huge search spaces or more challenging reasoning problems. In view of this, in this work, we put forward an advanced practice for neuro-symbolic reasoning systems to explore the intermediate labels with weak supervision from problem inputs and final outputs. Our experiments on the Mathematics dataset illustrated the effectiveness of our proposals from multiple aspects.
-   Link: https://arxiv.org/abs/2502.00629
-
-10. ARIES: Stimulating Self-Refinement of Large Language Models by Iterative Preference Optimization
-   Authors: Yongcheng Zeng, Xinyu Cui, Xuanfa Jin, Guoqing Liu, Zexu Sun, Quan He, Dong Li, Ning Yang, Jianye Hao, Haifeng Zhang, Jun Wang
-   Abstract: A truly intelligent Large Language Model (LLM) should be capable of correcting errors in its responses through external interactions. However, even the most advanced models often face challenges in improving their outputs. In this paper, we explore how to cultivate LLMs with the self-refinement capability through iterative preference training, and how this ability can be leveraged to improve model performance during inference. To this end, we introduce a novel post-training and inference framework, called ARIES: Adaptive Refinement and Iterative Enhancement Structure. This method iteratively performs preference training and self-refinement-based data collection. During training, ARIES strengthen the model's direct question-answering capability while simultaneously unlocking its self-refinement potential. During inference, ARIES harnesses this self-refinement capability to generate a series of progressively refined responses, which are then filtered using either the Reward Model Scoring or a simple yet effective Rule-Based Selection mechanism, specifically tailored to our approach, to construct a dataset for the next round of preference training. Experimental results demonstrate the remarkable performance of ARIES. When applied to the Llama-3.1-8B model and under the self-refinement setting, ARIES surpasses powerful models such as GPT-4o, achieving 62.3% length-controlled (LC) and a 63.3% raw win rates on AlpacaEval 2, outperforming Iterative DPO by 27.8% and 35.5% respectively, as well as a 50.3% win rate on Arena-Hard, surpassing Iterative DPO by 26.6%. Furthermore, ARIES consistently enhances performance on mathematical reasoning tasks like GSM8K and MATH.
-   Link: https://arxiv.org/abs/2502.05605
-
-Done!

octotools/tools/arxiv_paper_searcher/tool.py

@@ -1,165 +0,0 @@
-import re
-import requests
-from bs4 import BeautifulSoup
-
-from octotools.tools.base import BaseTool
-
-class ArXiv_Paper_Searcher_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="ArXiv_Paper_Searcher_Tool",
-            tool_description="A tool that searches arXiv for papers based on a given query.",
-            tool_version="1.0.0",
-            input_types={
-                "query": "str - The search query for arXiv papers.",
-                "size": "int - The number of results per page (25, 50, 100, or 200). If None, use 25.",
-                "max_results": "int - The maximum number of papers to return (default: 25). Should be less than or equal to 100."
-            },
-            output_type="list - A list of dictionaries containing paper information.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(query="tool agents with large language models")',
-                    "description": "Search for papers about tool agents with large language models."
-                },
-                {
-                    "command": 'execution = tool.execute(query="quantum computing", size=100, max_results=50)',
-                    "description": "Search for quantum computing papers, with 100 results per page, returning a maximum of 50 papers."
-                },
-                {
-                    "command": 'execution = tool.execute(query="machine learning", max_results=75)',
-                    "description": "Search for machine learning papers, returning a maximum of 75 papers."
-                },
-            ],
-            user_metadata={
-                "valid_sizes": [25, 50, 100, 200],
-                "base_url": "https://arxiv.org/search/"
-            }
-        )
-
-    def build_tool(self):
-        """
-        No specific build required for this tool.
-        """
-        pass
-
-    def execute(self, query, size=None, max_results=25):
-        """
-        Executes the arXiv search tool to find papers based on the given query.
-
-        Parameters:
-            query (str): The search query for arXiv papers.
-            size (int): The number of results per page.
-            max_results (int): The maximum number of papers to return.
-
-        Returns:
-            list: A list of dictionaries containing paper information.
-        """
-        valid_sizes = self.user_metadata["valid_sizes"]
-        base_url = self.user_metadata["base_url"]
-
-        if size is None:
-            size = 25
-        elif size not in valid_sizes:
-            size = min(valid_sizes, key=lambda x: abs(x - size))
-
-        results = []
-        start = 0
-
-        max_results = min(max_results, 100) # NOTE: For traffic reasons, limit to 100 results
-
-        while len(results) < max_results:
-            params = {
-                "searchtype": "all",
-                "query": query,
-                "abstracts": "show",
-                "order": "",
-                "size": str(size),
-                "start": str(start)
-            }
-
-            try:
-                response = requests.get(base_url, params=params)
-                soup = BeautifulSoup(response.content, 'html.parser')
-
-                papers = soup.find_all("li", class_="arxiv-result")
-                if not papers:
-                    break
-
-                for paper in papers:
-                    if len(results) >= max_results:
-                        break
-
-                    title = paper.find("p", class_="title").text.strip()
-                    authors = paper.find("p", class_="authors").text.strip()
-                    authors = re.sub(r'^Authors:\s*', '', authors)
-                    authors = re.sub(r'\s+', ' ', authors).strip()
-                    
-                    abstract = paper.find("span", class_="abstract-full").text.strip()
-                    abstract = abstract.replace("△ Less", "").strip()
-                    
-                    link = paper.find("p", class_="list-title").find("a")["href"]
-
-                    results.append({
-                        "title": title,
-                        "authors": authors,
-                        "abstract": abstract,
-                        "link": f"{link}"
-                    })
-
-                start += size
-
-            except Exception as e:
-                print(f"Error searching arXiv: {e}")
-                break
-
-        return results[:max_results]
-
-    def get_metadata(self):
-        """
-        Returns the metadata for the ArXiv_Paper_Searcher_Tool.
-
-        Returns:
-            dict: A dictionary containing the tool's metadata.
-        """
-        metadata = super().get_metadata()
-        return metadata
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools/tools/arxiv_paper_searcher
-    python tool.py
-    """
-
-    import json
-
-    print("ArXiv Search Tool Test")
-
-    # Example usage of the ArXiv_Paper_Searcher_Tool
-    tool = ArXiv_Paper_Searcher_Tool()
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print("Tool Metadata:")
-    print(metadata)
-
-    # Sample query for searching arXiv
-    query = "enhance mathematical reasoning with large language models"
-    # Execute the tool
-    try:
-        execution = tool.execute(query=query, size=50, max_results=10)
-        print("\n==>> Execution:")
-        print(json.dumps(execution, indent=4))  # Pretty print JSON
-        print("\n==>> Search Results:")
-        for i, paper in enumerate(execution, 1):
-            print(f"{i}. {paper['title']}")
-            print(f"   Authors: {paper['authors']}")
-            print(f"   Abstract: {paper['abstract'][:2000]}")
-            print(f"   Link: {paper['link']}")
-            print()
-    except Exception as e:
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/base.py

@@ -1,103 +0,0 @@
-# octotools/tools/base.py
-
-from octotools.engine.openai import ChatOpenAI
-
-class BaseTool:
-    """
-    A base class for building tool classes that perform specific tasks, such as image processing or text detection.
-    """
-
-    require_llm_engine = False  # Default is False, tools that need LLM should set this to True
-
-    def __init__(self, tool_name=None, tool_description=None, tool_version=None, input_types=None, output_type=None, demo_commands=None, output_dir=None, user_metadata=None, model_string=None):
-        """
-        Initialize the base tool with optional metadata.
-
-        Parameters:
-            tool_name (str): The name of the tool.
-            tool_description (str): A description of the tool.
-            tool_version (str): The version of the tool.
-            input_types (dict): The expected input types for the tool.
-            output_type (str): The expected output type for the tool.
-            demo_commands (list): A list of example commands for using the tool.
-            output_dir (str): The directory where the tool should save its output (optional).
-            user_metadata (dict): Additional metadata specific to user needs (optional).
-            model_string (str): The model string for the LLM engine (optional, only used if require_llm_engine is True).
-        """
-        self.tool_name = tool_name
-        self.tool_description = tool_description
-        self.tool_version = tool_version
-        self.input_types = input_types
-        self.output_type = output_type
-        self.demo_commands = demo_commands
-        self.output_dir = output_dir
-        self.user_metadata = user_metadata
-        self.model_string = model_string
-
-    def set_metadata(self, tool_name, tool_description, tool_version, input_types, output_type, demo_commands, user_metadata=None):
-        """
-        Set the metadata for the tool.
-
-        Parameters:
-            tool_name (str): The name of the tool.
-            tool_description (str): A description of the tool.
-            tool_version (str): The version of the tool.
-            input_types (dict): The expected input types for the tool.
-            output_type (str): The expected output type for the tool.
-            demo_commands (list): A list of example commands for using the tool.
-            user_metadata (dict): Additional metadata specific to user needs (optional).
-        """
-        self.tool_name = tool_name
-        self.tool_description = tool_description
-        self.tool_version = tool_version
-        self.input_types = input_types
-        self.output_type = output_type
-        self.demo_commands = demo_commands
-        self.user_metadata = user_metadata
-
-    def get_metadata(self):
-        """
-        Returns the metadata for the tool.
-
-        Returns:
-            dict: A dictionary containing the tool's metadata.
-        """
-        metadata = {
-            "tool_name": self.tool_name,
-            "tool_description": self.tool_description,
-            "tool_version": self.tool_version,
-            "input_types": self.input_types,
-            "output_type": self.output_type,
-            "demo_commands": self.demo_commands,
-            "require_llm_engine": self.require_llm_engine,
-        }
-        if self.user_metadata:
-            metadata["user_metadata"] = self.user_metadata
-        return metadata
-
-    def set_custom_output_dir(self, output_dir):
-        """
-        Set a custom output directory for the tool.
-
-        Parameters:
-            output_dir (str): The new output directory path.
-        """
-        self.output_dir = output_dir
-
-    def set_llm_engine(self, model_string):
-        """
-        Set the LLM engine for the tool.
-
-        Parameters:
-            model_string (str): The model string for the LLM engine.
-        """
-        self.model_string = model_string
-
-    def execute(self, *args, **kwargs):
-        """
-        Execute the tool's main functionality. This method should be overridden by subclasses.
-
-        Raises:
-            NotImplementedError: If the subclass does not implement this method.
-        """
-        raise NotImplementedError("Subclasses must implement the execute method.")

octotools/tools/generalist_solution_generator/tool.py

@@ -1,144 +0,0 @@
-import os
-from octotools.tools.base import BaseTool
-from octotools.engine.openai import ChatOpenAI
-
-class Generalist_Solution_Generator_Tool(BaseTool):
-    require_llm_engine = True
-    require_api_key = True
-
-    def __init__(self, model_string="gpt-4o-mini", api_key=None):
-        super().__init__(
-            tool_name="Generalist_Solution_Generator_Tool",
-            tool_description="A generalized tool that takes query from the user as prompt, and answers the question step by step to the best of its ability. It can also accept an image.",
-            tool_version="1.0.0",
-            input_types={
-                "prompt": "str - The prompt that includes query from the user to guide the agent to generate response (Examples: 'Describe this image in detail').",
-                "image": "str - The path to the image file if applicable (default: None).",
-            },
-            output_type="str - The generated response to the original query prompt",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(prompt="Summarize the following text in a few lines")',
-                    "description": "Generate a short summary given the prompt from the user."
-                },
-                {
-                    "command": 'execution = tool.execute(prompt="Explain the mood of this scene.", image="path/to/image1.png")',
-                    "description": "Generate a caption focusing on the mood using a specific prompt and image."
-                },
-                {
-                    "command": 'execution = tool.execute(prompt="Give your best coordinate estimate for the pacemaker in the image and return (x1, y1, x2, y2)", image="path/to/image2.png")',
-                    "description": "Generate bounding box coordinates given the image and prompt from the user. The format should be (x1, y1, x2, y2)."
-                },
-                {
-                    "command": 'execution = tool.execute(prompt="Is the number of tiny objects that are behind the small metal jet less than the number of tiny things left of the tiny sedan?", image="path/to/image2.png")',
-                    "description": "Answer a question step by step given the image."
-                }
-            ],
-            # # vesion 0 (bowen) (Generalist: %; 6 Tools: %; Generalist + 6 Tools: %)
-            # user_metadata = {
-            #     "limitation": "The Generalist_Solution_Generator_Tool may provide hallucinated or incorrect responses.",
-            #     "best_practice": "Use the Generalist_Solution_Generator_Tool for general queries or tasks that don't require specialized knowledge. For optimal results: 1) Provide clear, specific prompts. 2) Use it as a starting point for complex tasks, then refine with specialized tools. 3) Verify important information from its responses. 4) For image-related tasks, ensure the image path is correct and the prompt is relevant to the image content."
-            # }
-            # vesion 2 (Generalist: 68%; 6 Tools: 66%; Generalist + 6 Tools: 54%)
-            user_metadata = {
-                "limitation": "The Generalist_Solution_Generator_Tool may provide hallucinated or incorrect responses.",
-                "best_practice": "Use the Generalist_Solution_Generator_Tool for general queries or tasks that don't require specialized knowledge or specific tools in the toolbox. For optimal results:\n\n"
-                "1) Provide clear, specific prompts.\n"
-                "2) Use it to answer the original query through step by step reasoning for tasks without complex or multi-step reasoning.\n"
-                "3) For complex queries, break them down into subtasks and use the tool multiple times.\n"
-                "4) Use it as a starting point for complex tasks, then refine with specialized tools.\n"
-                "5) Verify important information from its responses.\n"
-                "6) For image-related tasks, ensure the image path is correct and the prompt is relevant to the image content."
-            }
-            # # vesion 6 (Generalist: 70%; 6 Tools: 66%; Generalist + 6 Tools: 60%)
-            # user_metadata = {
-            #     "limitation": "The Generalist_Solution_Generator_Tool may provide hallucinated or incorrect responses.",
-            #     "best_practice": "Use the Generalist_Solution_Generator_Tool for general queries or tasks that don't require specialized knowledge or specific tools in the toolbox. For optimal results:\n\n"
-            #     "1) Provide clear, specific prompts.\n"
-            #     "2) Use it to answer the original query through step by step reasoning for tasks without complex or multi-step reasoning.\n"
-            #     "3) For complex queries, break them down into smaller, focused sub-tasks and use the tool multiple times.\n"
-            #     "4) Use it as a starting point for complex tasks, then refine with specialized tools.\n"
-            #     "5) Verify important information from its responses.\n"
-            #     "6) For image-related tasks, ensure the image path is correct and the prompt is relevant to the image content."
-            # }
-            # # vesion 8 (Generalist: 68%; 6 Tools: 66%; Generalist + 6 Tools: 60%)
-            # user_metadata = {
-            #     "limitation": "The Generalist_Solution_Generator_Tool may provide hallucinated or incorrect responses.",
-            #     "best_practice": "Use the Generalist_Solution_Generator_Tool for general queries or tasks that don't require specialized knowledge or specific tools in the toolbox. For optimal results:\n\n"
-            #     "1) Provide clear, specific prompts.\n"
-            #     "2) Use it to answer the original query through step by step reasoning for tasks without complex or multi-step reasoning.\n"
-            #     "3) Use it as a starting point for complex tasks, then refine with specialized tools.\n"
-            #     "4) Verify important information from its responses.\n"
-            #     "5) For image-related tasks, ensure the image path is correct and the prompt is relevant to the image content."
-            # }
-        )
-        self.model_string = model_string  
-        self.api_key = api_key
-
-    def execute(self, prompt, image=None):
-
-        print(f"\nInitializing Generalist Tool with model: {self.model_string}")
-        multimodal = True if image else False
-        llm_engine = ChatOpenAI(model_string=self.model_string, is_multimodal=multimodal, api_key=self.api_key)
-
-        try:
-            input_data = [prompt]
-            if multimodal:
-                if not os.path.isfile(image):
-                    return "Error: Invalid image file path."
-                try:
-                    with open(image, 'rb') as file:
-                        image_bytes = file.read()
-                    input_data.append(image_bytes)
-                except Exception as e:
-                    return f"Error reading image file: {str(e)}"
-
-                response = llm_engine(input_data)
-            else:
-                response = llm_engine(input_data[0])
-            return response
-        except Exception as e:
-            return f"Error generating response: {str(e)}"
-
-    def get_metadata(self):
-        metadata = super().get_metadata()
-        return metadata
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools
-    python tools/default/tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    print(f"Script directory: {script_dir}")
-
-    # Example usage of the Generalist_Tool
-    tool = Generalist_Solution_Generator_Tool()
-    # tool = Generalist_Solution_Generator_Tool(model_string="gpt-4o-mini")
-    # tool = Generalist_Solution_Generator_Tool(model_string="gpt-4o")
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Construct the full path to the image using the script's directory
-    relative_image_path = "../../tasks/minitoolbench/data/mathvista_113.png"
-    relative_image_path = "examples/mathvista_113.png"
-    image_path = os.path.join(script_dir, relative_image_path)
-    prompt = "Describe the image in detail."
-
-    # Execute the tool with default prompt
-    try:
-        execution = tool.execute(prompt=prompt, image=image_path)
-        # execution = tool.execute(prompt=prompt)
-        print("Generated Response:")
-        print(execution)
-    except Exception as e: 
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/google_search/test.log

@@ -1,29 +0,0 @@
-{'tool_name': 'Google_Search_Tool', 'tool_description': 'A tool that performs Google searches based on a given text query.', 'tool_version': '1.0.0', 'input_types': {'query': 'str - The search query to be used for the Google search.', 'num_results': 'int - The number of search results to return (default: 10).'}, 'output_type': 'list - A list of dictionaries containing search result information.', 'demo_commands': [{'command': 'execution = tool.execute(query="Python programming")', 'description': "Perform a Google search for 'Python programming' and return the default number of results."}, {'command': 'execution = tool.execute(query="Machine learning tutorials", num_results=5)', 'description': "Perform a Google search for 'Machine learning tutorials' and return 5 results."}], 'require_llm_engine': False}
-{'kind': 'customsearch#search', 'url': {'type': 'application/json', 'template': 'https://www.googleapis.com/customsearch/v1?q={searchTerms}&num={count?}&start={startIndex?}&lr={language?}&safe={safe?}&cx={cx?}&sort={sort?}&filter={filter?}&gl={gl?}&cr={cr?}&googlehost={googleHost?}&c2coff={disableCnTwTranslation?}&hq={hq?}&hl={hl?}&siteSearch={siteSearch?}&siteSearchFilter={siteSearchFilter?}&exactTerms={exactTerms?}&excludeTerms={excludeTerms?}&linkSite={linkSite?}&orTerms={orTerms?}&dateRestrict={dateRestrict?}&lowRange={lowRange?}&highRange={highRange?}&searchType={searchType}&fileType={fileType?}&rights={rights?}&imgSize={imgSize?}&imgType={imgType?}&imgColorType={imgColorType?}&imgDominantColor={imgDominantColor?}&alt=json'}, 'queries': {'request': [{'title': 'Google Custom Search - nobel prize winners in chemistry 2024', 'totalResults': '1020000', 'searchTerms': 'nobel prize winners in chemistry 2024', 'count': 5, 'startIndex': 1, 'inputEncoding': 'utf8', 'outputEncoding': 'utf8', 'safe': 'off', 'cx': 'd5bb3fdd4b7fd4cd9'}], 'nextPage': [{'title': 'Google Custom Search - nobel prize winners in chemistry 2024', 'totalResults': '1020000', 'searchTerms': 'nobel prize winners in chemistry 2024', 'count': 5, 'startIndex': 6, 'inputEncoding': 'utf8', 'outputEncoding': 'utf8', 'safe': 'off', 'cx': 'd5bb3fdd4b7fd4cd9'}]}, 'context': {'title': 'toolbox-dev-pan'}, 'searchInformation': {'searchTime': 0.285868, 'formattedSearchTime': '0.29', 'totalResults': '1020000', 'formattedTotalResults': '1,020,000'}, 'items': [{'kind': 'customsearch#result', 'title': 'The Nobel Prize in Chemistry 2024', 'htmlTitle': 'The <b>Nobel Prize</b> in <b>Chemistry 2024</b>', 'link': 'https://www.nobelprize.org/prizes/chemistry/', 'displayLink': 'www.nobelprize.org', 'snippet': "The Nobel Prize in Chemistry 2024 is about proteins, life's ingenious chemical tools. David Baker has succeeded with the almost impossible feat of building\xa0...", 'htmlSnippet': 'The <b>Nobel Prize</b> in <b>Chemistry 2024</b> is about proteins, life&#39;s ingenious <b>chemical</b> tools. David Baker has succeeded with the almost impossible feat of building&nbsp;...', 'formattedUrl': 'https://www.nobelprize.org/prizes/chemistry/', 'htmlFormattedUrl': 'https://www.<b>nobelprize</b>.org/<b>prize</b>s/<b>chemistry</b>/', 'pagemap': {'hcard': [{'fn': 'Ernest Rutherford', 'url': 'https://www.nobelprize.org/prizes/chemistry/1908/rutherford/'}, {'fn': 'Marie Curie, née Skłodowska', 'url': 'https://www.nobelprize.org/prizes/physics/1903/marie-curie/'}, {'fn': 'Jacques Dubochet', 'url': 'https://www.nobelprize.org/prizes/chemistry/2017/dubochet/'}, {'fn': 'Dorothy Crowfoot Hodgkin', 'url': 'https://www.nobelprize.org/prizes/chemistry/1964/hodgkin/'}, {'fn': 'Linus Carl Pauling', 'url': 'https://www.nobelprize.org/prizes/chemistry/1954/pauling/'}, {'fn': 'Jean-Pierre Sauvage', 'url': 'https://www.nobelprize.org/prizes/chemistry/2016/sauvage/'}], 'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSOMs3quxSE4q1eWHocdDOr31q-aad13MSHgdUGUqpOG71sdtm6WGQ5BWAX&s', 'width': '276', 'height': '182'}], 'person': [{'name': 'Ernest Rutherford', 'url': 'Ernest Rutherford'}, {'name': 'Marie Curie, née Skłodowska', 'url': 'Marie Curie, née Skłodowska'}, {'name': 'Jacques Dubochet', 'url': 'Jacques Dubochet'}, {'name': 'Dorothy Crowfoot Hodgkin', 'url': 'Dorothy Crowfoot Hodgkin'}, {'name': 'Linus Carl Pauling', 'url': 'Linus Carl Pauling'}, {'name': 'Jean-Pierre Sauvage', 'url': 'Jean-Pierre Sauvage'}], 'organization': [{'url': 'https://www.nobelprize.org/'}, {'logo': 'Nobel Prize', 'url': 'Nobel Prize'}], 'metatags': [{'og:image': 'https://www.nobelprize.org/uploads/2018/09/New-will-fullsize-496x328.jpg', 'og:type': 'website', 'twitter:card': 'summary_large_image', 'twitter:title': 'Chemistry Prize', 'og:site_name': 'NobelPrize.org', 'og:title': 'Chemistry Prize', 'msapplication-tileimage': 'https://www.nobelprize.org/uploads/2018/08/Nobel-favicon.png', 'og:description': 'Chemistry Prize', 'twitter:image': 'https://www.nobelprize.org/uploads/2018/09/New-will-fullsize-496x328.jpg', 'viewport': 'width=device-width, initial-scale=1', 'twitter:description': 'Chemistry Prize', 'og:locale': 'en_US', 'og:url': 'https://www.nobelprize.org/chemistry-prize-2/'}], 'cse_image': [{'src': 'https://www.nobelprize.org/uploads/2018/09/New-will-fullsize-496x328.jpg'}], 'blogposting': [{'headline': 'They cracked the code for proteins’ amazing structures'}, {'headline': 'David Baker'}, {'headline': 'Demis Hassabis'}, {'headline': 'John Jumper'}, {'headline': 'The life of a chemist'}, {'headline': 'How many chemistry laureates can you match?'}, {'headline': 'What are the Nobel Prize categories?'}, {'headline': 'What did they discover?'}, {'headline': 'Who first predicted global warming?'}, {'headline': 'The world’s smallest machines'}, {'headline': 'Interview with a double awardee'}]}}, {'kind': 'customsearch#result', 'title': 'NSF congratulates laureates of the 2024 Nobel Prize in chemistry ...', 'htmlTitle': 'NSF congratulates <b>laureates</b> of the <b>2024 Nobel Prize</b> in <b>chemistry</b> ...', 'link': 'https://www.nsf.gov/news/nsf-congratulates-laureates-2024-nobel-prize-chemistry', 'displayLink': 'www.nsf.gov', 'snippet': 'Oct 9, 2024 ... The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the 2024 Nobel Prize in\xa0...', 'htmlSnippet': 'Oct 9, 2024 <b>...</b> The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the <b>2024 Nobel Prize</b> in&nbsp;...', 'formattedUrl': 'https://www.nsf.gov/.../nsf-congratulates-laureates-2024-nobel-prize-chemi...', 'htmlFormattedUrl': 'https://www.nsf.gov/.../nsf-congratulates-laureates-<b>2024</b>-<b>nobel</b>-<b>prize</b>-<b>chemi</b>...', 'pagemap': {'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRH1B2HTt4h0BsKt4cqcthiUWk5GDU2hX6k7mP1EQh0glR9n13NnR2pLX4&s', 'width': '360', 'height': '140'}], 'metatags': [{'og:image': 'https://nsf-gov-resources.nsf.gov/styles/_inline_image_full_width/s3/media_hub/nobel24-chemistry-news-hero-David-Baker-Demis-Hassabis-John-Jumper.jpg?VersionId=8Wa1DsrhgMw.SQEBdxmUOgtdCntLkWDb&itok=NIPtuWh-', 'og:image:width': '800', 'og:image:alt': 'sketch portraits of three men', 'twitter:card': 'summary_large_image', 'twitter:title': 'NSF congratulates laureates of the 2024 Nobel Prize in chemistry', 'og:site_name': 'NSF - National Science Foundation', 'handheldfriendly': 'true', 'og:title': 'NSF congratulates laureates of the 2024 Nobel Prize in chemistry', 'og:image:height': '312', 'og:description': 'The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the 2024 Nobel Prize in chemistry. Baker and his…', 'twitter:image': 'https://nsf-gov-resources.nsf.gov/styles/_inline_image_full_width/s3/media_hub/nobel24-chemistry-news-hero-David-Baker-Demis-Hassabis-John-Jumper.jpg?VersionId=8Wa1DsrhgMw.SQEBdxmUOgtdCntLkWDb&itok=NIPtuWh-', 'twitter:image:alt': 'sketch portraits of three men', 'twitter:site': '@NSF', 'viewport': 'width=device-width, initial-scale=1.0', 'twitter:description': 'The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the 2024 Nobel Prize in chemistry. Baker and his…', 'mobileoptimized': 'width', 'og:url': 'https://www.nsf.gov/news/nsf-congratulates-laureates-2024-nobel-prize-chemistry'}], 'cse_image': [{'src': 'https://nsf-gov-resources.nsf.gov/styles/_inline_image_full_width/s3/media_hub/nobel24-chemistry-news-hero-David-Baker-Demis-Hassabis-John-Jumper.jpg?VersionId=8Wa1DsrhgMw.SQEBdxmUOgtdCntLkWDb&itok=NIPtuWh-'}]}}, {'kind': 'customsearch#result', 'title': 'Press release: The Nobel Prize in Chemistry 2024 - NobelPrize.org', 'htmlTitle': 'Press release: The <b>Nobel Prize</b> in <b>Chemistry 2024</b> - <b>NobelPrize</b>.org', 'link': 'https://www.nobelprize.org/prizes/chemistry/2024/press-release/', 'displayLink': 'www.nobelprize.org', 'snippet': 'Oct 9, 2024 ... David Baker has succeeded with the almost impossible feat of building entirely new kinds of proteins. Demis Hassabis and John Jumper have\xa0...', 'htmlSnippet': 'Oct 9, 2024 <b>...</b> David Baker has succeeded with the almost impossible feat of building entirely new kinds of proteins. Demis Hassabis and John Jumper have&nbsp;...', 'formattedUrl': 'https://www.nobelprize.org/prizes/chemistry/2024/press-release/', 'htmlFormattedUrl': 'https://www.<b>nobelprize</b>.org/<b>prize</b>s/<b>chemistry</b>/<b>2024</b>/press-release/', 'pagemap': {'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQON_Hf1_dyrEACSiPsjRoTG2R4pjcDpbg7BAzGC9LovMbRHVei6GShrCM&s', 'width': '302', 'height': '167'}], 'organization': [{'url': 'https://www.nobelprize.org/'}, {'logo': 'Nobel Prize', 'url': 'Nobel Prize'}], 'metatags': [{'og:image': 'https://www.nobelprize.org/uploads/2024/10/popular-chemistryprize2024-carrier-1024x567.jpg', 'og:type': 'website', 'twitter:card': 'summary_large_image', 'twitter:title': 'Nobel Prize in Chemistry 2024', 'og:site_name': 'NobelPrize.org', 'og:title': 'Nobel Prize in Chemistry 2024', 'msapplication-tileimage': 'https://www.nobelprize.org/uploads/2018/08/Nobel-favicon.png', 'og:description': 'The Nobel Prize in Chemistry 2024 was divided, one half awarded to David Baker "for computational protein design", the other half jointly to Demis Hassabis and John Jumper "for protein structure prediction"', 'twitter:image': 'https://www.nobelprize.org/uploads/2024/10/popular-chemistryprize2024-carrier-1024x567.jpg', 'viewport': 'width=device-width, initial-scale=1', 'twitter:description': 'The Nobel Prize in Chemistry 2024 was divided, one half awarded to David Baker "for computational protein design", the other half jointly to Demis Hassabis and John Jumper "for protein structure prediction"', 'og:locale': 'en_US', 'og:url': 'https://www.nobelprize.org/prizes/chemistry/2024/press-release/'}], 'cse_image': [{'src': 'https://www.nobelprize.org/uploads/2024/10/popular-chemistryprize2024-carrier-1024x567.jpg'}]}}, {'kind': 'customsearch#result', 'title': 'AIP Congratulates 2024 Nobel Prize Winners in Chemistry - AIP.ORG', 'htmlTitle': 'AIP Congratulates <b>2024 Nobel Prize Winners in Chemistry</b> - AIP.ORG', 'link': 'https://ww2.aip.org/aip/2024-nobel-prize-in-chemistry', 'displayLink': 'ww2.aip.org', 'snippet': 'Oct 9, 2024 ... The 2024 Nobel Prize in chemistry was awarded with one half to David Baker “for computational protein design” and the other half jointly to Demis Hassabis and\xa0...', 'htmlSnippet': 'Oct 9, 2024 <b>...</b> The <b>2024 Nobel Prize</b> in <b>chemistry</b> was awarded with one half to David Baker “for computational protein design” and the other half jointly to Demis Hassabis and&nbsp;...', 'formattedUrl': 'https://ww2.aip.org/aip/2024-nobel-prize-in-chemistry', 'htmlFormattedUrl': 'https://ww2.aip.org/aip/<b>2024</b>-<b>nobel</b>-<b>prize</b>-in-<b>chemistry</b>', 'pagemap': {'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTyVGKJaR9X7VE3Y97Z_j8IXIconF0D0zUe88ATVyBuFSXya-CrM1qsveY&s', 'width': '300', 'height': '168'}], 'metatags': [{'og:image': 'https://aip.brightspotcdn.com/dims4/default/079290d/2147483647/strip/true/crop/1200x675+0+0/resize/1440x810!/quality/90/?url=https%3A%2F%2Fk1-prod-aip.s3.us-east-2.amazonaws.com%2Fbrightspot%2F07%2F96%2Fbc7d9a594949bc49f983177d6781%2Fnobel-2024-chem-i01.jpg', 'og:image:width': '1440', 'og:image:alt': 'Nobel-2024-Chem-i01.jpg', 'og:type': 'article', 'article:published_time': '2024-10-09T12:28:31.16', 'article:section': 'AIP', 'twitter:card': 'summary_large_image', 'og:site_name': 'AIP', 'og:image:url': 'https://aip.brightspotcdn.com/dims4/default/079290d/2147483647/strip/true/crop/1200x675+0+0/resize/1440x810!/quality/90/?url=https%3A%2F%2Fk1-prod-aip.s3.us-east-2.amazonaws.com%2Fbrightspot%2F07%2F96%2Fbc7d9a594949bc49f983177d6781%2Fnobel-2024-chem-i01.jpg', 'og:image:height': '810', 'og:image:type': 'image/jpeg', 'twitter:image': 'https://aip.brightspotcdn.com/dims4/default/079290d/2147483647/strip/true/crop/1200x675+0+0/resize/1440x810!/quality/90/?url=https%3A%2F%2Fk1-prod-aip.s3.us-east-2.amazonaws.com%2Fbrightspot%2F07%2F96%2Fbc7d9a594949bc49f983177d6781%2Fnobel-2024-chem-i01.jpg', 'twitter:image:alt': 'Nobel-2024-Chem-i01.jpg', 'fb:app_id': '643005150655973', 'article:modified_time': '2024-10-09T18:23:12.852', 'viewport': 'width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=5', 'brightspot.contentid': '00000192-70e9-da7e-a1fe-fcff80d40000', 'og:url': 'https://ww2.aip.org/aip/2024-nobel-prize-in-chemistry'}], 'cse_image': [{'src': 'https://aip.brightspotcdn.com/dims4/default/079290d/2147483647/strip/true/crop/1200x675+0+0/resize/1440x810!/quality/90/?url=https%3A%2F%2Fk1-prod-aip.s3.us-east-2.amazonaws.com%2Fbrightspot%2F07%2F96%2Fbc7d9a594949bc49f983177d6781%2Fnobel-2024-chem-i01.jpg'}]}}, {'kind': 'customsearch#result', 'title': 'The Nobel Prize in Chemistry 2024 - NobelPrize.org', 'htmlTitle': 'The <b>Nobel Prize</b> in <b>Chemistry 2024</b> - <b>NobelPrize</b>.org', 'link': 'https://www.nobelprize.org/prizes/chemistry/2024/summary/', 'displayLink': 'www.nobelprize.org', 'snippet': 'David Baker · Demis Hassabis · John Jumper · Nobel Prizes and laureates\xa0...', 'htmlSnippet': 'David Baker &middot; Demis Hassabis &middot; John Jumper &middot; <b>Nobel Prizes</b> and <b>laureates</b>&nbsp;...', 'formattedUrl': 'https://www.nobelprize.org/prizes/chemistry/2024/summary/', 'htmlFormattedUrl': 'https://www.<b>nobelprize</b>.org/<b>prize</b>s/<b>chemistry</b>/<b>2024</b>/summary/', 'pagemap': {'hcard': [{'fn': 'David Baker', 'url': 'https://www.nobelprize.org/prizes/chemistry/2024/baker/facts/'}, {'fn': 'Demis Hassabis', 'url': 'https://www.nobelprize.org/prizes/chemistry/2024/hassabis/facts/'}, {'fn': 'John Jumper', 'url': 'https://www.nobelprize.org/prizes/chemistry/2024/jumper/facts/'}], 'cse_thumbnail': [{'src': 'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcT4UpOxZHEJhIvhwQsypTDggUJ3pJf_wG3U3jZBDyK8l-Qyqx99fVknWr8Y&s', 'width': '259', 'height': '194'}], 'person': [{'name': 'David Baker', 'description': 'Prize share: 1/2', 'url': 'David Baker'}, {'name': 'Demis Hassabis', 'description': 'Prize share: 1/4', 'url': 'Demis Hassabis'}, {'name': 'John Jumper', 'description': 'Prize share: 1/4', 'url': 'John Jumper'}], 'organization': [{'url': 'https://www.nobelprize.org/'}, {'logo': 'Nobel Prize', 'url': 'Nobel Prize'}], 'metatags': [{'og:image': 'https://www.nobelprize.org/uploads/2024/10/fig_ke_24_4x3-1024x768.jpg', 'og:type': 'website', 'twitter:card': 'summary_large_image', 'twitter:title': 'Nobel Prize in Chemistry 2024', 'og:site_name': 'NobelPrize.org', 'og:title': 'Nobel Prize in Chemistry 2024', 'msapplication-tileimage': 'https://www.nobelprize.org/uploads/2018/08/Nobel-favicon.png', 'og:description': 'The Nobel Prize in Chemistry 2024 was divided, one half awarded to David Baker "for computational protein design", the other half jointly to Demis Hassabis and John Jumper "for protein structure prediction"', 'twitter:image': 'https://www.nobelprize.org/uploads/2024/10/fig_ke_24_4x3-1024x768.jpg', 'viewport': 'width=device-width, initial-scale=1', 'twitter:description': 'The Nobel Prize in Chemistry 2024 was divided, one half awarded to David Baker "for computational protein design", the other half jointly to Demis Hassabis and John Jumper "for protein structure prediction"', 'og:locale': 'en_US', 'og:url': 'https://www.nobelprize.org/prizes/chemistry/2024/summary/'}], 'cse_image': [{'src': 'https://www.nobelprize.org/uploads/2024/10/fig_ke_24_4x3-1024x768.jpg'}]}}]}
-
-Execution Result:
-Search query: nobel prize winners in chemistry 2024
-Number of results: 5
-
-Search Results:
-
-1. Title: The Nobel Prize in Chemistry 2024
-   URL: https://www.nobelprize.org/prizes/chemistry/
-   Snippet: The Nobel Prize in Chemistry 2024 is about proteins, life's ingenious chemical tools. David Baker has succeeded with the almost impossible feat of building ...
-
-2. Title: NSF congratulates laureates of the 2024 Nobel Prize in chemistry ...
-   URL: https://www.nsf.gov/news/nsf-congratulates-laureates-2024-nobel-prize-chemistry
-   Snippet: Oct 9, 2024 ... The U.S. National Science Foundation congratulates David Baker, Demis Hassabis and John Jumper on being awarded the 2024 Nobel Prize in ...
-
-3. Title: Press release: The Nobel Prize in Chemistry 2024 - NobelPrize.org
-   URL: https://www.nobelprize.org/prizes/chemistry/2024/press-release/
-   Snippet: Oct 9, 2024 ... David Baker has succeeded with the almost impossible feat of building entirely new kinds of proteins. Demis Hassabis and John Jumper have ...
-
-4. Title: AIP Congratulates 2024 Nobel Prize Winners in Chemistry - AIP.ORG
-   URL: https://ww2.aip.org/aip/2024-nobel-prize-in-chemistry
-   Snippet: Oct 9, 2024 ... The 2024 Nobel Prize in chemistry was awarded with one half to David Baker “for computational protein design” and the other half jointly to Demis Hassabis and ...
-
-5. Title: The Nobel Prize in Chemistry 2024 - NobelPrize.org
-   URL: https://www.nobelprize.org/prizes/chemistry/2024/summary/
-   Snippet: David Baker · Demis Hassabis · John Jumper · Nobel Prizes and laureates ...
-Done!

octotools/tools/google_search/tool.py

@@ -1,136 +0,0 @@
-import os
-import requests
-from typing import List, Dict, Any
-
-from octotools.tools.base import BaseTool
-
-from dotenv import load_dotenv
-load_dotenv()
-
-class Google_Search_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="Google_Search_Tool",
-            tool_description="A tool that performs Google searches based on a given text query.",
-            tool_version="1.0.0",
-            input_types={
-                "query": "str - The search query to be used for the Google search.",
-                "num_results": "int - The number of search results to return (default: 10).",
-            },
-            output_type="list - A list of dictionaries containing search result information.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(query="Python programming")',
-                    "description": "Perform a Google search for 'Python programming' and return the default number of results."
-                },
-                {
-                    "command": 'execution = tool.execute(query="Machine learning tutorials", num_results=5)',
-                    "description": "Perform a Google search for 'Machine learning tutorials' and return 5 results."
-                },
-            ],
-        )
-        # self.api_key = os.getenv("GOOGLE_API_KEY")
-        self.api_key = os.getenv("GOOGLE_API_KEY") # NOTE: Replace with your own API key (Ref: https://developers.google.com/custom-search/v1/introduction)
-        self.cx = os.getenv("GOOGLE_CX") # NOTE: Replace with your own custom search (Ref: https://programmablesearchengine.google.com/controlpanel/all)
-        self.base_url = "https://www.googleapis.com/customsearch/v1"
-
-    def google_search(self, query: str, num_results: int = 10) -> Dict[str, Any]:
-        """
-        Performs a Google search using the provided query.
-
-        Parameters:
-            query (str): The search query.
-            num_results (int): The number of search results to return.
-
-        Returns:
-            Dict[str, Any]: The raw search results from the Google API.
-        """
-        params = {
-            'q': query,
-            'key': self.api_key,
-            'cx': self.cx,
-            'num': num_results
-        }
-        
-        response = requests.get(self.base_url, params=params)
-        return response.json()
-
-    def execute(self, query: str, num_results: int = 10) -> List[Dict[str, Any]]:
-        """
-        Executes a Google search based on the provided query.
-
-        Parameters:
-            query (str): The search query.
-            num_results (int): The number of search results to return (default: 10).
-
-        Returns:
-            List[Dict[str, Any]]: A list of dictionaries containing search result information.
-        """
-        if not self.api_key:
-            return [{"error": "Google API key is not set. Please set the GOOGLE_API_KEY environment variable."}]
-
-        try:
-            results = self.google_search(query, num_results)
-            print(results)
-            
-            if 'items' in results:
-                return [
-                    {
-                        "title": item['title'],
-                        "link": item['link'],
-                        "snippet": item['snippet']
-                    }
-                    for item in results['items']
-                ]
-            else:
-                return [{"error": "No results found."}]
-        except Exception as e:
-            return [{"error": f"An error occurred: {str(e)}"}]
-
-    def get_metadata(self):
-        """
-        Returns the metadata for the Google_Search_Tool.
-
-        Returns:
-            dict: A dictionary containing the tool's metadata.
-        """
-        metadata = super().get_metadata()
-        return metadata
-
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-
-    export GOOGLE_API_KEY=your_api_key_here
-    cd octotools/tools/google_search
-    python tool.py
-    """
-
-    # Example usage of the Google_Search_Tool
-    tool = Google_Search_Tool()
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Execute the tool to perform a Google search
-    query = "nobel prize winners in chemistry 2024"
-    try:
-        execution = tool.execute(query=query, num_results=5)
-        print("\nExecution Result:")
-        print(f"Search query: {query}")
-        print(f"Number of results: {len(execution)}")
-        print("\nSearch Results:")
-        if "error" in execution[0]:
-            print(f"Error: {execution[0]['error']}")
-        else:
-            for i, item in enumerate(execution, 1):
-                print(f"\n{i}. Title: {item['title']}")
-                print(f"   URL: {item['link']}")
-                print(f"   Snippet: {item['snippet']}")
-    except Exception as e:
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/image_captioner/test.log

@@ -1,7 +0,0 @@
-
-Initializing Image Captioner Tool with model: gpt-4o
-!! Cache enabled for model: gpt-4o
-{'tool_name': 'Image_Captioner_Tool', 'tool_description': "A tool that generates captions for images using OpenAI's multimodal model.", 'tool_version': '1.0.0', 'input_types': {'image': 'str - The path to the image file.', 'prompt': "str - The prompt to guide the image captioning (default: 'Describe this image in detail.')."}, 'output_type': 'str - The generated caption for the image.', 'demo_commands': [{'command': 'execution = tool.execute(image="path/to/image.png")', 'description': 'Generate a caption for an image using the default prompt and model.'}, {'command': 'execution = tool.execute(image="path/to/image.png", prompt="Explain the mood of this scene.")', 'description': 'Generate a caption focusing on the mood using a specific prompt and model.'}], 'require_llm_engine': True, 'user_metadata': {'limitation': 'The Image_Captioner_Tool provides general image descriptions but has limitations: 1) May make mistakes in complex scenes, counting, attribute detection, and understanding object relationships. 2) Might not generate comprehensive captions, especially for images with multiple objects or abstract concepts. 3) Performance varies with image complexity. 4) Struggles with culturally specific or domain-specific content. 5) May overlook details or misinterpret object relationships. For precise descriptions, consider: using it with other tools for context/verification, as an initial step before refinement, or in multi-step processes for ambiguity resolution. Verify critical information with specialized tools or human expertise when necessary.'}}
-Generated Caption:
-"The image shows four blue buckets, each containing five baseballs. The buckets are arranged in a grid pattern with three on the top row and one on the bottom left. Each bucket has a handle on the side, and the baseballs inside are white with red stitching, typical of standard baseballs. The background is plain white, emphasizing the buckets and their contents."
-Done!

octotools/tools/image_captioner/tool.py

@@ -1,96 +0,0 @@
-import os
-from octotools.tools.base import BaseTool
-from octotools.engine.openai import ChatOpenAI
-
-class Image_Captioner_Tool(BaseTool):
-    require_llm_engine = True
-
-    def __init__(self, model_string="gpt-4o-mini"):
-        super().__init__(
-            tool_name="Image_Captioner_Tool",
-            tool_description="A tool that generates captions for images using OpenAI's multimodal model.",
-            tool_version="1.0.0",
-            input_types={
-                "image": "str - The path to the image file.",
-                "prompt": "str - The prompt to guide the image captioning (default: 'Describe this image in detail.').",
-            },
-            output_type="str - The generated caption for the image.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png")',
-                    "description": "Generate a caption for an image using the default prompt and model."
-                },
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png", prompt="Explain the mood of this scene.")',
-                    "description": "Generate a caption focusing on the mood using a specific prompt and model."
-                }
-            ],
-            user_metadata = {
-                "limitation": "The Image_Captioner_Tool provides general image descriptions but has limitations: 1) May make mistakes in complex scenes, counting, attribute detection, and understanding object relationships. 2) Might not generate comprehensive captions, especially for images with multiple objects or abstract concepts. 3) Performance varies with image complexity. 4) Struggles with culturally specific or domain-specific content. 5) May overlook details or misinterpret object relationships. For precise descriptions, consider: using it with other tools for context/verification, as an initial step before refinement, or in multi-step processes for ambiguity resolution. Verify critical information with specialized tools or human expertise when necessary."
-            },
-        )
-        print(f"\nInitializing Image Captioner Tool with model: {model_string}")
-        self.llm_engine = ChatOpenAI(model_string=model_string, is_multimodal=True) if model_string else None
-
-    def execute(self, image, prompt="Describe this image in detail."):
-        try:
-            if not self.llm_engine:
-                return "Error: LLM engine not initialized. Please provide a valid model_string."
-                
-            input_data = [prompt]
-            
-            if image and os.path.isfile(image):
-                try:
-                    with open(image, 'rb') as file:
-                        image_bytes = file.read()
-                    input_data.append(image_bytes)
-                except Exception as e:
-                    return f"Error reading image file: {str(e)}"
-            else:
-                return "Error: Invalid image file path."
-
-            caption = self.llm_engine(input_data)
-            return caption
-        except Exception as e:
-            return f"Error generating caption: {str(e)}"
-
-    def get_metadata(self):
-        metadata = super().get_metadata()
-        metadata['require_llm_engine'] = self.require_llm_engine # NOTE: can be removed if not needed
-        return metadata
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools/tools/image_captioner
-    python tool.py
-    """
-
-    import json
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the Image_Captioner_Tool
-    # tool = Image_Captioner_Tool()
-    tool = Image_Captioner_Tool(model_string="gpt-4o")
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Construct the full path to the image using the script's directory
-    relative_image_path = "examples/baseball.png"
-    image_path = os.path.join(script_dir, relative_image_path)
-
-    # Execute the tool with default prompt
-    try:
-        execution = tool.execute(image=image_path)
-        print("Generated Caption:")
-        print(json.dumps(execution, indent=4)) 
-    except Exception as e: 
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/nature_news_fetcher/test.log

@@ -1,180 +0,0 @@
-{'tool_name': 'Nature_News_Fetcher_Tool', 'tool_description': 'A tool that fetches the latest news articles from Nature.', 'tool_version': '1.0.0', 'input_types': {'num_articles': 'int - The number of articles to fetch (default: 100).', 'max_pages': 'int - The maximum number of pages to fetch (default: 5).'}, 'output_type': 'list - A list of dictionaries containing information about the latest Nature news articles.', 'demo_commands': [{'command': 'execution = tool.execute()', 'description': 'Fetch the latest 100 news articles from Nature.'}, {'command': 'execution = tool.execute(num_articles=50, max_pages=3)', 'description': 'Fetch the latest 50 news articles from Nature, searching up to 3 pages.'}], 'require_llm_engine': False}
-[
-    {
-        "title": "NASA embraced diversity. Trump\u2019s DEI purge is hitting space scientists hard",
-        "url": "https://www.nature.com/articles/d41586-025-00480-x",
-        "description": "Some researchers at NASA and outside it feel betrayed by the changes at the agency, which was known for promoting inclusion in science.",
-        "authors": [
-            "Alexandra Witze"
-        ],
-        "date": "2025-02-14",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00480-x/d41586-025-00480-x_50636314.jpg"
-    },
-    {
-        "title": "Are the Trump team\u2019s actions affecting your research? How to contact Nature",
-        "url": "https://www.nature.com/articles/d41586-025-00479-4",
-        "description": "Use this form to share information with Nature\u2019s news team, or to make suggestions for future coverage.",
-        "authors": [
-            "No authors found"
-        ],
-        "date": "2025-02-13",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00479-4/d41586-025-00479-4_50626000.jpg"
-    },
-    {
-        "title": "Scientists use AI to design life-like enzymes from scratch",
-        "url": "https://www.nature.com/articles/d41586-025-00488-3",
-        "description": "Combined approach takes AI-engineered enzymes one step closer to practical applications.",
-        "authors": [
-            "Miryam Naddaf"
-        ],
-        "date": "2025-02-13",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00488-3/d41586-025-00488-3_50636094.jpg"
-    },
-    {
-        "title": "Royal Society will meet amid campaign to revoke Elon Musk\u2019s fellowship",
-        "url": "https://www.nature.com/articles/d41586-025-00486-5",
-        "description": "More than 1,300 scientists have signed a letter calling on the world\u2019s oldest science society to reassess the billionaire\u2019s membership following cuts to US science.",
-        "authors": [
-            "Holly Else"
-        ],
-        "date": "2025-02-13",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00486-5/d41586-025-00486-5_50635956.jpg"
-    },
-    {
-        "title": "Vaccine sceptic RFK Jr is now a powerful force in US science: what will he do?",
-        "url": "https://www.nature.com/articles/d41586-025-00439-y",
-        "description": "Kennedy has expressed support for some fields, but has also declared he\u2019d like a \u2018break\u2019 in infectious-disease research.",
-        "authors": [
-            "Amanda Heidt",
-            "Heidi Ledford"
-        ],
-        "date": "2025-02-13",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00439-y/d41586-025-00439-y_50621992.jpg"
-    },
-    {
-        "title": "Are PhDs losing their lustre? Why fewer students are enrolling in doctoral degrees",
-        "url": "https://www.nature.com/articles/d41586-025-00425-4",
-        "description": "High living costs paired with stagnant stipends are being blamed for a drop in PhD enrolments in several countries.",
-        "authors": [
-            "Diana Kwon"
-        ],
-        "date": "2025-02-13",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00425-4/d41586-025-00425-4_50621644.jpg"
-    },
-    {
-        "title": "Quantum-computing technology that makes qubits from atoms wins mega investment",
-        "url": "https://www.nature.com/articles/d41586-025-00451-2",
-        "description": "Firms using \u2018neutral atoms\u2019 to create qubits are reentering the race to build useful quantum machines.",
-        "authors": [
-            "Elizabeth Gibney"
-        ],
-        "date": "2025-02-13",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00451-2/d41586-025-00451-2_50636260.jpg"
-    },
-    {
-        "title": "Cheap blood test detects pancreatic cancer before it spreads",
-        "url": "https://www.nature.com/articles/d41586-025-00438-z",
-        "description": "The deadly cancer is often not found until it has spread to other parts of the body.",
-        "authors": [
-            "Smriti Mallapaty"
-        ],
-        "date": "2025-02-12",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00438-z/d41586-025-00438-z_50621748.jpg"
-    },
-    {
-        "title": "How centuries of isolation shaped Greenlanders\u2019 unique genetics",
-        "url": "https://www.nature.com/articles/d41586-025-00443-2",
-        "description": "Centuries of isolation have given Greenlanders a genetic profile that includes Arctic-specific variants.",
-        "authors": [
-            "Freda Kreier"
-        ],
-        "date": "2025-02-12",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00443-2/d41586-025-00443-2_50625480.jpg"
-    },
-    {
-        "title": "Record-breaking neutrino is most energetic ever detected",
-        "url": "https://www.nature.com/articles/d41586-025-00444-1",
-        "description": "Although still under construction, the sea-floor KM3NeT detector spotted a neutrino 20 times more powerful than any previously detected.",
-        "authors": [
-            "Davide Castelvecchi"
-        ],
-        "date": "2025-02-12",
-        "image_url": "https://media.springernature.com/w290h158/magazine-assets/d41586-025-00444-1/d41586-025-00444-1_50625568.jpg"
-    }
-]
-
-Execution Result:
-Number of articles fetched: 10
-
-Sample articles:
-
-1. Title: NASA embraced diversity. Trump’s DEI purge is hitting space scientists hard
-   URL: https://www.nature.com/articles/d41586-025-00480-x
-   Description: Some researchers at NASA and outside it feel betrayed by the changes at the agency, which was known ...
-   Authors: Alexandra Witze
-   Date: 2025-02-14
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00480-x/d41586-025-00480-x_50636314.jpg
-
-2. Title: Are the Trump team’s actions affecting your research? How to contact Nature
-   URL: https://www.nature.com/articles/d41586-025-00479-4
-   Description: Use this form to share information with Nature’s news team, or to make suggestions for future covera...
-   Authors: No authors found
-   Date: 2025-02-13
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00479-4/d41586-025-00479-4_50626000.jpg
-
-3. Title: Scientists use AI to design life-like enzymes from scratch
-   URL: https://www.nature.com/articles/d41586-025-00488-3
-   Description: Combined approach takes AI-engineered enzymes one step closer to practical applications....
-   Authors: Miryam Naddaf
-   Date: 2025-02-13
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00488-3/d41586-025-00488-3_50636094.jpg
-
-4. Title: Royal Society will meet amid campaign to revoke Elon Musk’s fellowship
-   URL: https://www.nature.com/articles/d41586-025-00486-5
-   Description: More than 1,300 scientists have signed a letter calling on the world’s oldest science society to rea...
-   Authors: Holly Else
-   Date: 2025-02-13
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00486-5/d41586-025-00486-5_50635956.jpg
-
-5. Title: Vaccine sceptic RFK Jr is now a powerful force in US science: what will he do?
-   URL: https://www.nature.com/articles/d41586-025-00439-y
-   Description: Kennedy has expressed support for some fields, but has also declared he’d like a ‘break’ in infectio...
-   Authors: Amanda Heidt, Heidi Ledford
-   Date: 2025-02-13
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00439-y/d41586-025-00439-y_50621992.jpg
-
-6. Title: Are PhDs losing their lustre? Why fewer students are enrolling in doctoral degrees
-   URL: https://www.nature.com/articles/d41586-025-00425-4
-   Description: High living costs paired with stagnant stipends are being blamed for a drop in PhD enrolments in sev...
-   Authors: Diana Kwon
-   Date: 2025-02-13
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00425-4/d41586-025-00425-4_50621644.jpg
-
-7. Title: Quantum-computing technology that makes qubits from atoms wins mega investment
-   URL: https://www.nature.com/articles/d41586-025-00451-2
-   Description: Firms using ‘neutral atoms’ to create qubits are reentering the race to build useful quantum machine...
-   Authors: Elizabeth Gibney
-   Date: 2025-02-13
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00451-2/d41586-025-00451-2_50636260.jpg
-
-8. Title: Cheap blood test detects pancreatic cancer before it spreads
-   URL: https://www.nature.com/articles/d41586-025-00438-z
-   Description: The deadly cancer is often not found until it has spread to other parts of the body....
-   Authors: Smriti Mallapaty
-   Date: 2025-02-12
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00438-z/d41586-025-00438-z_50621748.jpg
-
-9. Title: How centuries of isolation shaped Greenlanders’ unique genetics
-   URL: https://www.nature.com/articles/d41586-025-00443-2
-   Description: Centuries of isolation have given Greenlanders a genetic profile that includes Arctic-specific varia...
-   Authors: Freda Kreier
-   Date: 2025-02-12
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00443-2/d41586-025-00443-2_50625480.jpg
-
-10. Title: Record-breaking neutrino is most energetic ever detected
-   URL: https://www.nature.com/articles/d41586-025-00444-1
-   Description: Although still under construction, the sea-floor KM3NeT detector spotted a neutrino 20 times more po...
-   Authors: Davide Castelvecchi
-   Date: 2025-02-12
-   Image URL: https://media.springernature.com/w290h158/magazine-assets/d41586-025-00444-1/d41586-025-00444-1_50625568.jpg
-Done!

octotools/tools/nature_news_fetcher/tool.py

@@ -1,181 +0,0 @@
-import os
-import requests
-from bs4 import BeautifulSoup
-import time
-
-from octotools.tools.base import BaseTool
-
-class Nature_News_Fetcher_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="Nature_News_Fetcher_Tool",
-            tool_description="A tool that fetches the latest news articles from Nature.",
-            tool_version="1.0.0",
-            input_types={
-                "num_articles": "int - The number of articles to fetch (default: 100).",
-                "max_pages": "int - The maximum number of pages to fetch (default: 5).",
-            },
-            output_type="list - A list of dictionaries containing information about the latest Nature news articles.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute()',
-                    "description": "Fetch the latest 100 news articles from Nature."
-                },
-                {
-                    "command": 'execution = tool.execute(num_articles=50, max_pages=3)',
-                    "description": "Fetch the latest 50 news articles from Nature, searching up to 3 pages."
-                },
-            ],
-        )
-        self.base_url = "https://www.nature.com/nature/articles"
-
-    def fetch_page(self, page_number):
-        """
-        Fetches a single page of news articles from Nature's website.
-
-        Parameters:
-            page_number (int): The page number to fetch.
-
-        Returns:
-            str: The HTML content of the page.
-        """
-        params = {
-            "searchType": "journalSearch",
-            "sort": "PubDate",
-            "type": "news",
-            "page": str(page_number)
-        }
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
-        }
-        response = requests.get(self.base_url, params=params, headers=headers)
-        response.raise_for_status()
-        return response.text
-
-    def parse_articles(self, html_content):
-        """
-        Parses the HTML content and extracts article information.
-
-        Parameters:
-            html_content (str): The HTML content of the page.
-
-        Returns:
-            list: A list of dictionaries containing article information.
-        """
-        soup = BeautifulSoup(html_content, 'html.parser')
-        articles_section = soup.find('section', id='new-article-list')
-        if not articles_section:
-            return []
-
-        articles = []
-        for article in articles_section.find_all('article', class_='c-card'):
-            title_elem = article.find('h3', class_='c-card__title')
-            title = title_elem.text.strip() if title_elem else "No title found"
-            
-            url_elem = title_elem.find('a') if title_elem else None
-            url = "https://www.nature.com" + url_elem['href'] if url_elem and 'href' in url_elem.attrs else "No URL found"
-            
-            description_elem = article.find('div', {'data-test': 'article-description'})
-            description = description_elem.text.strip() if description_elem else "No description available"
-            
-            authors_elem = article.find('ul', {'data-test': 'author-list'})
-            authors = [author.text.strip() for author in authors_elem.find_all('li')] if authors_elem else ["No authors found"]
-            
-            date_elem = article.find('time')
-            date = date_elem['datetime'] if date_elem and 'datetime' in date_elem.attrs else "No date found"
-
-            image_elem = article.find('img')
-            image_url = image_elem['src'] if image_elem and 'src' in image_elem.attrs else "No image found"
-
-            articles.append({
-                'title': title,
-                'url': url,
-                'description': description,
-                'authors': authors,
-                'date': date,
-                'image_url': image_url
-            })
-
-        return articles
-
-    def execute(self, num_articles=100, max_pages=5):
-        """
-        Fetches the latest news articles from Nature's website.
-
-        Parameters:
-            num_articles (int): The number of articles to fetch.
-            max_pages (int): The maximum number of pages to fetch.
-
-        Returns:
-            list: A list of dictionaries containing article information.
-        """
-        all_articles = []
-        page_number = 1
-
-        try:
-            while len(all_articles) < num_articles and page_number <= max_pages:
-                html_content = self.fetch_page(page_number)
-                page_articles = self.parse_articles(html_content)
-                
-                if not page_articles:
-                    break  # No more articles found
-
-                all_articles.extend(page_articles)
-                page_number += 1
-                time.sleep(1)  # Be polite to the server
-
-            return all_articles[:num_articles]
-        except Exception as e:
-            return [{"error": str(e)}]
-
-    def get_metadata(self):
-        """
-        Returns the metadata for the Nature_News_Fetcher_Tool.
-
-        Returns:
-            dict: A dictionary containing the tool's metadata.
-        """
-        metadata = super().get_metadata()
-        return metadata
-
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-
-    cd octotools/tools/nature_news_fetcher
-    python tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the Nature_News_Fetcher_Tool
-    tool = Nature_News_Fetcher_Tool()
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    import json
-  
-
-    # Execute the tool to fetch the latest 10 articles (for demonstration purposes)
-    try:
-        execution = tool.execute(num_articles=10, max_pages=1)
-        print(json.dumps(execution, indent=4))
-        print("\nExecution Result:")
-        print(f"Number of articles fetched: {len(execution)}")
-        print("\nSample articles:")
-        for i, article in enumerate(execution[:10], 1):
-            print(f"\n{i}. Title: {article['title']}")
-            print(f"   URL: {article['url']}")
-            print(f"   Description: {article['description'][:100]}...")  # Show first 100 characters
-            print(f"   Authors: {', '.join(article['authors'])}")
-            print(f"   Date: {article['date']}")
-            print(f"   Image URL: {article['image_url']}")
-    except Exception as e:
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/object_detector/test.log

@@ -1,112 +0,0 @@
-Could not load the custom kernel for multi-scale deformable attention: Command '['which', 'c++']' returned non-zero exit status 1.
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-Could not load the custom kernel for multi-scale deformable attention: /root/.cache/torch_extensions/py310_cu121/MultiScaleDeformableAttention/MultiScaleDeformableAttention.so: cannot open shared object file: No such file or directory
-CUDA_HOME is not set
-{'tool_name': 'Object_Detector_Tool', 'tool_description': 'A tool that detects objects in an image using the Grounding DINO model and saves individual object images with empty padding.', 'tool_version': '1.0.0', 'input_types': {'image': 'str - The path to the image file.', 'labels': 'list - A list of object labels to detect.', 'threshold': 'float - The confidence threshold for detection (default: 0.35).', 'model_size': "str - The size of the model to use ('tiny' or 'base', default: 'tiny').", 'padding': 'int - The number of pixels to add as empty padding around detected objects (default: 20).'}, 'output_type': 'list - A list of detected objects with their scores, bounding boxes, and saved image paths.', 'demo_commands': [{'command': 'execution = tool.execute(image="path/to/image.png", labels=["baseball", "basket"])', 'description': 'Detect baseball and basket in an image, save the detected objects with default empty padding, and return their paths.'}, {'command': 'execution = tool.execute(image="path/to/image.png", labels=["car", "person"], threshold=0.5, model_size="base", padding=15)', 'description': 'Detect car and person in an image using the base model, save the detected objects with 15 pixels of empty padding, and return their paths.'}], 'require_llm_engine': False, 'user_metadata': {'limitation': 'The model may not always detect objects accurately, and its performance can vary depending on the input image and the associated labels. It typically struggles with detecting small objects, objects that are uncommon, or objects with limited or specific attributes. For improved accuracy or better detection in certain situations, consider using supplementary tools or image processing techniques to provide additional information for verification.'}}
-Detected Objects:
-Detected baseball with confidence 0.69
-Bounding box: (558, 48, 615, 107)
-Saved image (with padding): detected_objects/baseball_baseball_1.png
-
-Detected baseball with confidence 0.69
-Bounding box: (614, 137, 671, 191)
-Saved image (with padding): detected_objects/baseball_baseball_2.png
-
-Detected baseball with confidence 0.68
-Bounding box: (132, 67, 189, 126)
-Saved image (with padding): detected_objects/baseball_baseball_3.png
-
-Detected baseball with confidence 0.68
-Bounding box: (632, 67, 690, 126)
-Saved image (with padding): detected_objects/baseball_baseball_4.png
-
-Detected baseball with confidence 0.68
-Bounding box: (57, 289, 115, 346)
-Saved image (with padding): detected_objects/baseball_baseball_5.png
-
-Detected baseball with confidence 0.68
-Bounding box: (535, 111, 592, 170)
-Saved image (with padding): detected_objects/baseball_baseball_6.png
-
-Detected baseball with confidence 0.68
-Bounding box: (307, 48, 365, 107)
-Saved image (with padding): detected_objects/baseball_baseball_7.png
-
-Detected baseball with confidence 0.68
-Bounding box: (114, 137, 171, 191)
-Saved image (with padding): detected_objects/baseball_baseball_8.png
-
-Detected baseball with confidence 0.68
-Bounding box: (35, 351, 91, 410)
-Saved image (with padding): detected_objects/baseball_baseball_9.png
-
-Detected baseball with confidence 0.68
-Bounding box: (57, 48, 115, 107)
-Saved image (with padding): detected_objects/baseball_baseball_10.png
-
-Detected baseball with confidence 0.68
-Bounding box: (35, 111, 91, 170)
-Saved image (with padding): detected_objects/baseball_baseball_11.png
-
-Detected baseball with confidence 0.68
-Bounding box: (364, 137, 421, 191)
-Saved image (with padding): detected_objects/baseball_baseball_12.png
-
-Detected baseball with confidence 0.68
-Bounding box: (114, 377, 171, 430)
-Saved image (with padding): detected_objects/baseball_baseball_13.png
-
-Detected baseball with confidence 0.67
-Bounding box: (132, 307, 189, 366)
-Saved image (with padding): detected_objects/baseball_baseball_14.png
-
-Detected baseball with confidence 0.67
-Bounding box: (285, 111, 342, 170)
-Saved image (with padding): detected_objects/baseball_baseball_15.png
-
-Detected baseball with confidence 0.67
-Bounding box: (382, 67, 439, 126)
-Saved image (with padding): detected_objects/baseball_baseball_16.png
-
-Detected baseball with confidence 0.65
-Bounding box: (587, 94, 643, 153)
-Saved image (with padding): detected_objects/baseball_baseball_17.png
-
-Detected baseball with confidence 0.65
-Bounding box: (86, 94, 143, 153)
-Saved image (with padding): detected_objects/baseball_baseball_18.png
-
-Detected baseball with confidence 0.65
-Bounding box: (86, 335, 143, 393)
-Saved image (with padding): detected_objects/baseball_baseball_19.png
-
-Detected baseball with confidence 0.63
-Bounding box: (336, 95, 393, 153)
-Saved image (with padding): detected_objects/baseball_baseball_20.png
-
-Detected basket with confidence 0.59
-Bounding box: (252, 2, 468, 215)
-Saved image (with padding): detected_objects/baseball_basket_1.png
-
-Detected basket with confidence 0.55
-Bounding box: (503, 2, 717, 215)
-Saved image (with padding): detected_objects/baseball_basket_2.png
-
-Detected basket with confidence 0.54
-Bounding box: (2, 2, 217, 215)
-Saved image (with padding): detected_objects/baseball_basket_3.png
-
-Detected basket with confidence 0.5
-Bounding box: (2, 242, 217, 455)
-Saved image (with padding): detected_objects/baseball_basket_4.png
-
-Done!

octotools/tools/object_detector/tool.py

@@ -1,179 +0,0 @@
-# Grounding DINO Object Detection Tool
-# https://huggingface.co/IDEA-Research/grounding-dino
-
-import os
-import time
-import torch
-from transformers import pipeline
-
-from octotools.tools.base import BaseTool
-from PIL import Image, ImageOps
-
-import os
-# If CUDA_HOME is set, print the value
-print(os.environ.get('CUDA_HOME', 'CUDA_HOME is not set'))
-
-# Suppress stderr by redirecting it to /dev/null
-import sys
-sys.stderr = open(os.devnull, 'w')
-
-import warnings
-warnings.filterwarnings("ignore")
-
-
-class Object_Detector_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="Object_Detector_Tool",
-            tool_description="A tool that detects objects in an image using the Grounding DINO model and saves individual object images with empty padding.",
-            tool_version="1.0.0",
-            input_types={
-                "image": "str - The path to the image file.",
-                "labels": "list - A list of object labels to detect.",
-                "threshold": "float - The confidence threshold for detection (default: 0.35).",
-                "model_size": "str - The size of the model to use ('tiny' or 'base', default: 'tiny').",
-                "padding": "int - The number of pixels to add as empty padding around detected objects (default: 20)."
-            },
-            output_type="list - A list of detected objects with their scores, bounding boxes, and saved image paths.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png", labels=["baseball", "basket"])',
-                    "description": "Detect baseball and basket in an image, save the detected objects with default empty padding, and return their paths."
-                },
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png", labels=["car", "person"], threshold=0.5, model_size="base", padding=15)',
-                    "description": "Detect car and person in an image using the base model, save the detected objects with 15 pixels of empty padding, and return their paths."
-                }
-            ],
-            user_metadata={
-                "limitation": "The model may not always detect objects accurately, and its performance can vary depending on the input image and the associated labels. It typically struggles with detecting small objects, objects that are uncommon, or objects with limited or specific attributes. For improved accuracy or better detection in certain situations, consider using supplementary tools or image processing techniques to provide additional information for verification."
-            }
-        )
-
-    def preprocess_caption(self, caption):
-        result = caption.lower().strip()
-        if result.endswith("."):
-            return result
-        return result + "."
-
-    def build_tool(self, model_size='tiny'):
-        model_name = f"IDEA-Research/grounding-dino-{model_size}"
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        try:
-            pipe = pipeline(model=model_name, task="zero-shot-object-detection", device=device)
-            return pipe
-        except Exception as e:
-            print(f"Error building the Object Detection tool: {e}")
-            return None
-
-    def save_detected_object(self, image, box, image_name, label, index, padding):
-        object_image = image.crop(box)
-        padded_image = ImageOps.expand(object_image, border=padding, fill='white')
-        
-        filename = f"{image_name}_{label}_{index}.png"
-        os.makedirs(self.output_dir, exist_ok=True)
-        save_path = os.path.join(self.output_dir, filename)
-        
-        padded_image.save(save_path)
-        return save_path
-
-    def execute(self, image, labels, threshold=0.35, model_size='tiny', padding=20, max_retries=10, retry_delay=5, clear_cuda_cache=False):
-        for attempt in range(max_retries):
-            try:
-                saved_files = []
-
-                pipe = self.build_tool(model_size)
-                if pipe is None:
-                    raise ValueError("Failed to build the Object Detection tool.")
-                
-                preprocessed_labels = [self.preprocess_caption(label) for label in labels]
-                results = pipe(image, candidate_labels=preprocessed_labels, threshold=threshold)
-                
-                formatted_results = []
-                original_image = Image.open(image)
-                image_name = os.path.splitext(os.path.basename(image))[0]
-                
-                object_counts = {}
-
-                for result in results:
-                    box = tuple(result["box"].values())
-                    label = result["label"]
-                    score = round(result["score"], 2)
-                    if label.endswith("."):
-                        label = label[:-1]
-                    
-                    object_counts[label] = object_counts.get(label, 0) + 1
-                    index = object_counts[label]
-                    
-                    save_path = self.save_detected_object(original_image, box, image_name, label, index, padding)
-            
-                    formatted_results.append({
-                        "label": label,
-                        "confidence score": score,
-                        "box": box,
-                        "saved_image_path": save_path
-                    })
-
-                return formatted_results
-            
-            except RuntimeError as e:
-                if "CUDA out of memory" in str(e):
-                    print(f"CUDA out of memory error on attempt {attempt + 1}.")
-                    if clear_cuda_cache:
-                        print("Clearing CUDA cache and retrying...")
-                        torch.cuda.empty_cache()
-                    else:
-                        print(f"Retrying in {retry_delay} seconds...")
-                    time.sleep(retry_delay)
-                    continue
-                else:
-                    print(f"Runtime error: {e}")
-                    break
-            except Exception as e:
-                print(f"Error detecting objects: {e}")
-                break
-        
-        print(f"Failed to detect objects after {max_retries} attempts.")
-        return []
-
-    def get_metadata(self):
-        metadata = super().get_metadata()
-        return metadata
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools/tools/object_detector
-    python tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the Object_Detector_Tool
-    tool = Object_Detector_Tool()
-    tool.set_custom_output_dir("detected_objects")
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Construct the full path to the image using the script's directory
-    relative_image_path = "examples/baseball.png"
-    image_path = os.path.join(script_dir, relative_image_path)
-
-    # Execute the tool
-    try:
-        execution = tool.execute(image=image_path, labels=["baseball", "basket"], padding=20)
-        print("Detected Objects:")
-        for obj in execution:
-            print(f"Detected {obj['label']} with confidence {obj['confidence score']}")
-            print(f"Bounding box: {obj['box']}")
-            print(f"Saved image (with padding): {obj['saved_image_path']}")
-            print()
-    except ValueError as e: 
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/pubmed_search/test.log

@@ -1,3 +0,0 @@
-2025-02-14 19:03:45 06a0c5b0e177 metapub.config[158535] WARNING NCBI_API_KEY was not set.
-[{'title': 'Safety of health workers during the COVID-19 pandemic and beyond: piloting WHO framework in Iran.', 'abstract': "BACKGROUND: Health Workers Safety (HWS) is a global health priority and essential at all times, in stable situations, in emergencies, in disease epidemics or pandemics. This study aimed to assess HWS during the COVID-19 Pandemic.\nMETHODS: This cross-sectional study was conducted in 2022 in east Azerbaijan province, Iran. HWS was assessed based on 22 indicators suggested by WHO EMRO. We selected 15 PHC facilities and six wards from two hospitals randomly. Data collected (qualitative and quantitative) using national digital health records, staff records, and indicator-specific tools. In addition to measuring the indicator's value, the indicators' feasibility was also assessed. Descriptive and inferential statistics with SPSS-16 were used for data analysis.\nRESULTS: Totally, 325 Health Workers (HWs) (218 from PHC facilities and 107 from hospitals) participated in the study. Most of the participants in PHC facilities and hospitals were Community Health Workers (CHWs) (Moragheb Salamat) (45.4%) and nurses (37.38%), respectively. Most of HWs had completed the full vaccination schedule for Hepatitis B and COVID-19. Personal Protective Equipment (PPE) safety protocols were adhered by most of HWs within a healthcare facility. None of managers had attended nationally certified training for mental health support for health and care workers. Less than 20% of HWs participated in the work burnout prevention courses and most of HWs complained about work overload, or burnout. The job satisfaction level of hospital HWs (60.20%) was significantly higher than that of HWs from PHC facilities (57.18%) (P\u2009<\u20090.001).\nCONCLUSION: Even though the mental health of HWs was not as expected, the indicators related to physical health and occupational health were at a suitable level. Also, there is not a system in PHC to audit the application of safety measures to mitigate the risk of contracting COVID-19. We recommend creating a specific system (precise and detailed) for HWs' safety and applying safety measures in the PHC routine programs.", 'keywords': ['Assessment', 'COVID-19 pandemic', 'Health worker', 'Iran', 'Safety'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39920792'}, {'title': 'Experiences of working as a clinical nurse while pregnant during the coronavirus disease-2019 pandemic: a qualitative study.', 'abstract': 'BACKGROUND: Working as a pregnant clinical nurse might experience a range of challenges, such as significant anatomical and physiological changes as well as emotional and cognitive changes. That might be particularly obvious under the historical background of coronavirus disease-2019 (COVID-19) pandemic. However, a dearth of studies has explored the experiences of working as a pregnant nurse during this special period. This study aimed to explore the experiences of working as a clinical nurse while pregnant during the COVID-19 pandemic.\nMETHODS: A descriptive qualitative design was selected. Purposive sampling, combined with maximum variation strategy and snowball sampling, were utilized to identify and select participants from tertiary-teaching hospitals, specialized hospitals, and community hospitals in Zhejiang Province, southeastern China. Online semi-structured individual interviews were used to collect data, and conventional content analysis was used to analyze the data.\nRESULTS: Eleven Chinese nurses with a mean age of 31.8 years, ranging from 26 to 40 years, participated in this study. Four themes and twelve subthemes emerged: (1) still adhering to work as a clinical nurse despite being pregnant during the pandemic; (2) working during pregnancy under pandemic is still an ordinary nurse; (3) still staying in the special life phase as a pregnant mother; and (4) growth and gains as pregnant mother.\nCONCLUSION: The pregnant clinical nurses suffered from various changes and difficulties during the pandemic. Managers, occupational health and other health system leaders, and policymakers should be aware of the importance of establishing a work environment that guarantees safe continued pregnancy. Future studies should focus on the establishment of specific guidelines and manuals regarding how pregnant nurses worked, as well as the development of self-protection interventions during pregnancy. Moreover, research on moral stigma and bullying in nursing during pregnancy deserves further exploration.\nCLINICAL TRIAL NUMBER: Not applicable.', 'keywords': ['COVID-19 pandemic', 'Experiences', 'Nurse', 'Pregnant', 'Qualitative research'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39901239'}, {'title': "Development and psychometric validation of the frontline health workers' occupational risk and characteristics in emergencies index (FORCE-index) - The covid Hospital cohort study.", 'abstract': "OBJECTIVES: A lack of tools for the systematic identification of frontline health workers' changing occupational risks, characteristics, and needs, poses a major barrier to supporting vital personnel to stay in practice through health emergencies and beyond. The current study reports on the development and psychometric evaluation of the Frontline health workers' Occupational Risk and Characteristics in Emergencies index (FORCE-index).\nSTUDY DESIGN: The Covid hospital study is a large, multisite, four-wave, open cohort study of frontline health workers responding to the first four waves of the COVID-19 pandemic (2020-2022).\nMETHODS: 2496 frontline health workers responded to questionnaires assessing various aspects of their work environment. Using exploratory factor analysis, we estimated the latent structure of the FORCE-index at the first and second waves. This structure was evaluated using confirmatory factor analysis at the third and fourth waves. The internal consistency of the instrument's subscales (e.g., factors) was evaluated using omega reliability, Cronbach's alpha coefficient, and mean inter-item correlation.\nRESULTS: A nine-factor solution provided best fit to the data. These factors mapped onto the following aspects of the work environment; competency, stress management, familiarity, workload manageability, work performance, infection safety, personal protective equipment, social safety, and social support. Internal consistency for the full FORCE-index and the nine factors was satisfactory.\nCONCLUSIONS: The initial psychometric validation indicates that the FORCE-index is a valid measure which can be used by health authorities, services, and institutions to adequately and systematically assess central aspects of frontline health workers' work environment that are commonly challenged in health emergencies.", 'keywords': ['Covid-19', 'Frontline', 'Health Personnel', 'Health care worker', 'Health emergency', 'Health response', 'Hospital', 'Index', 'Infectious outbreak', 'Job characteristics', 'Occupational Health', 'Occupational diseases', 'Occupational exposure', 'Occupational stress', 'Preparedness', 'Preparedness planning', 'Psychometric', 'Scale', 'Stress', 'Work environment'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39896339'}, {'title': "A descriptive analysis of nurses' self-reported mental health symptoms during the COVID-19 pandemic: An international study.", 'abstract': "AIM: To describe the self-reported mental health of nurses from 35 countries who worked during the COVID-19 pandemic.\nBACKGROUND: There is little occupationally specific data about nurses' mental health worldwide. Studies have documented the impact on nurses' mental health of the COVID-19 pandemic, but few have baseline referents.\nMETHODS: A descriptive, cross-sectional design structured the study. Data reflect a convenience sample of\xa09,387 participants who completed the opt-in survey between July 31, 2022, and October 31, 2023. Descriptive statistics were run to analyze the following variables associated with mental health: Self-reports of mental health symptoms, burnout, personal losses during the pandemic, access to mental health services, and self-care practices used to cope with pandemic-related stressors. Reporting of this study was steered by the STROBE guideline for quantitative studies.\nRESULTS: Anxiety or depression occurred at rates ranging from 23%-61%, with country-specific trends in reporting observed. Approximately 18% of the sample reported experiencing some symptoms of burnout. The majority of nurses' employers did not provide mental health support in the workplace. Most reported more frequently engaging with self-care practices compared with before the pandemic. Notably, 20% of nurses suffered the loss of a family member, 35% lost a friend, and 34% a coworker due to COVID-19. Nearly half (48%) reported experiencing public aggression due to their identity as a nurse.\nCONCLUSIONS: The data obtained establish a basis for understanding the specific mental health needs of the nursing workforce globally, highlighting key areas for service development.\nIMPLICATIONS FOR NURSING POLICY: Healthcare organizations and governmental bodies need to develop targeted mental health support programs that are readily accessible to nurses to foster a resilient nursing workforce.", 'keywords': ['COVID‐19', 'global health', 'health workforce', 'nursing', 'nursing shortage', 'occupational health', 'occupational health nursing', 'pandemics'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39871528'}, {'title': 'Work Psychology and Occupational Health: An Editorial.', 'abstract': "Globally, the COVID-19 pandemic has severely impacted workers' health, particularly their mental well-being [...].", 'keywords': [], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39857553'}, {'title': 'Analysis of HFE impact of COVID-19 on OHS in construction enterprises.', 'abstract': "Human factors are critical to Occupational Health and Safety (OHS) in construction enterprises. However, comprehensive industry-wide recognition remains challenging, underscoring the need for Human Factors Engineering (HFE) research. This study develops an optimized HFE evaluation model based on fundamental HFE principles. Examining COVID-19's significant impact on construction enterprise OHS, this research employs an empirical investigation of 259 cases, utilizing a model that integrates NetLogo's System Dynamics (SD) and Multiple Linear Regression (MLR) to analyze the interactions between human factors and other variables. The findings reveal four key factors influencing human factors: management, material, environmental, and methodological. These factors demonstrate a quadratic parabolic relationship, with peak influence occurring at step 36 of the research period. Twelve of the 20 survey factors exhibit a linear regression relationship with human factors' four sub-factors, with pre-job training (Q<sub>9</sub>) demonstrating multiple influential interactions. The strongest correlation is between pre-job training (Q<sub>9</sub>) and living materials (Q<sub>14</sub>), with a weight coefficient of .325. Psychological counseling (Q<sub>8</sub>) and living materials (Q<sub>14</sub>) show a close relationship (weight coefficient .301). Notably, Q<sub>9</sub> and empirical prevention materials (Q<sub>11</sub>) display a negative correlation with a weight coefficient of -.156. This study's practical significance lies in enabling enterprises to identify key HFE control factors and understand critical sub-factors for mitigating COVID-19's adverse impacts.", 'keywords': ['COVID-19', 'Human factors engineering (HFE)', 'Multiple linear regression (MLR)', 'NetLogo', 'Occupational health and safety (OHS)', 'System dynamics (SD)'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39811363'}, {'title': 'COVID-19 workplace countermeasures that occupational physicians could not change in Japan: a qualitative study.', 'abstract': 'BACKGROUND: During the COVID-19 pandemic, information and circumstances changed from moment to moment, including the accumulation of scientific knowledge, the emergence of variants, social tolerance, and government policy. Therefore, it was important to adapt workplace countermeasures punctually and flexibly based on scientific evidence and according to circumstances. However, there has been no assessment of changes in workplace countermeasures. With a view toward preparedness for future pandemics, we surveyed COVID-19 workplace countermeasures that occupational physicians considered as needing to be changed but went unchanged.\nMETHODS: We invited 685 professional occupational physicians certified by Japan Society for Occupational Health to complete an online questionnaire by sending postcards with QR codes. The main questions concerned countermeasures that the participants wanted to change but could not. The survey period was from February 21 to April 28, 2022. The responses were analyzed using the KJ method.\nRESULTS: Of the 168 invitees (24.5%) who responded to the survey, 125 reported countermeasures that needed to be changed (total count: 254). The responses were categorized into basic systems, occupational health services, workplace countermeasures, vaccines, and incidents, with a code count of 7, 8,147, 10, and 82, respectively. The type of countermeasure was 115 for countermeasures to be strengthened (CBS), 110 for measures to be mitigated (CBM), and 29 for neither.\nCONCLUSIONS: Often-mentioned CBS were increased teleworking, strengthened ventilation, smoking cessation, and promotion of vaccines. Often-mentioned CBM were relaxation of protective equipment rules, discontinued environmental disinfection, and shorted isolation and reinstatement. In the early pandemic phases, CBSs were frequently mentioned, whereas CBMs were featured more prominently in the latter phases. The survey revealed countermeasures that occupational physicians thought needed to be changed but were not changed in practice. For future responses to emerging and reemerging infectious diseases, it will be necessary to establish rules compatible with flexible modification of workplace countermeasures in response to changing circumstances.', 'keywords': ['COVID-19', 'Japan', 'Occupational health', 'Occupational physician', 'Workers', 'Workplace', 'Workplace countermeasures'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39780108'}, {'title': 'Rapid COVID-19 Testing of Symptomatic Health Care Personnel: A Strategy for Safely Maintaining the Workforce.', 'abstract': 'Determine performance characteristics and safety outcomes of two rapid COVID-19 screening methods to inform immediate return to work (RTW) decisions while (health care personnel) HCP await results of pending confirmatory laboratory test. Retrospective, occupational health quality improvement study comparing screening with rapid SARS-CoV-2 nucleic acid amplification (NAAT) and antigen test. 531 mildly symptomatic HCP screened over 16 months. Until more accurate affordable NAAT tests become available, antigen test screening alone addresses simultaneous needs to minimize COVID-19 transmission from symptomatic HCP and maintain an adequate workforce.', 'keywords': [], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39739739'}, {'title': 'Satisfaction and Workload as Predictors of Psychological Distress in Professionals of Psychosocial Care Centers During the COVID-19 Pandemic.', 'abstract': 'BACKGROUND AND AIMS: The COVID-19 pandemic significantly impacted the mental health of healthcare professionals, especially those working in Psychosocial Care Centers (CAPS), which are crucial services in the Brazilian mental health system. This study aimed to investigate the association between job satisfaction, workload, and psychological distress among CAPS professionals during the pandemic.\nMETHODS: A cross-sectional study was conducted with 53 professionals from seven CAPS. The Workload Impact Scale (IMPACTO-BR) and Job Satisfaction Scale (SATIS-BR), the General Health Questionnaire (GHQ-12), and a sociodemographic questionnaire were used. Descriptive and analytical statistical analyses were performed. Multiple linear regression analysis was conducted to examine the relationship between job satisfaction, workload, and psychological distress.\nRESULTS: Professionals reported moderate satisfaction (3.67 ± 0.45) and mild workload (1.82 ± 0.63). One-third of the sample showed scores indicative of psychological distress. Multiple linear regression analysis revealed that workload (p = 0.0025) and low job satisfaction (p = 0.0495) were significantly associated with psychological distress.\nCONCLUSIONS: Low job satisfaction and high professional workload were predictive variables of psychological distress. These findings highlight the need for investments in promoting the quality of life at work for mental health professionals, especially during crises. The implications for human resource management and public policy development emphasize the importance of an integrated approach that considers the well-being of professionals for the effectiveness and sustainability of the psychosocial care model.', 'keywords': ['COVID-19', 'health personnel', 'job satisfaction', 'mental health', 'mental health services', 'occupational health'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39728651'}, {'title': 'Occupational-related risk of testing SARS-CoV-2 positive for publicly employed medical doctors in Sweden: A nationwide cohort study.', 'abstract': 'AIMS: Doctors have an increased risk of SARS-CoV-2 infection caused by exposure to contagious patients. We aimed to identify which clinical specialities among medical doctors had the highest occupation-related risk of testing positive for SARS-CoV-2, utilizing data for all publicly employed medical doctors in Sweden.\nMETHODS: Data regarding positive SARS-CoV-2 test results and employment for publicly employed doctors in Sweden were divided into three observation periods: 1) 1 February to 31 December 2020, 2) 1 January to 30 June 2021 and 3) 1 July 2021 to 31 March 2022. Individuals were stratified according to occupation clinic and compared with clinical occupations with little to no patient contact. The risk of testing positive for SARS-CoV-2 was estimated using Cox proportional hazards regression, with sex, age and vaccination status as covariates.\nRESULTS: The study cohort included all publicly employed doctors in Sweden: 35,028 individuals. In the first period, Infectious Disease doctors had the highest incidence of SARS-CoV-2 positive tests, with an incidence of 20.2 %, compared with 8.7 % in the reference group, and an adjusted hazard ratio of 2.5 (95% confidence interval 2.02-3.04), which decreased during period 2-3. Doctors in Geriatric Medicine had an elevated risk throughout the whole study period.\nCONCLUSIONS: Our study shows an association between working in a speciality that involves caring for contagious COVID-19 patients, which raises concerns about infection control measures and routines being insufficient to prevent occupational infection in future pandemics.', 'keywords': ['COVID-19', 'Occupational health', 'SARS-CoV-2', 'healthcare workers', 'medical doctors', 'risk factors'], 'url': 'https://ncbi.nlm.nih.gov/pubmed/39726065'}]
-Done!

octotools/tools/pubmed_search/tool.py

@@ -1,112 +0,0 @@
-import os
-import json
-from pymed import PubMed
-from metapub import PubMedFetcher
-from octotools.tools.base import BaseTool
-from tenacity import (
-    retry,
-    stop_after_attempt,
-    wait_random_exponential,
-)
-
-# Suppress stderr by redirecting it to /dev/null
-import sys
-sys.stderr = open(os.devnull, 'w')
-
-import warnings
-warnings.filterwarnings("ignore")
-
-
-class Pubmed_Search_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="Pubmed_Search_Tool",
-            tool_description="A tool that searches PubMed Central to retrieve relevant article abstracts based on a given list of text queries. Use this ONLY if you cannot use the other more specific ontology tools.",
-            tool_version="1.0.0",
-            input_types={
-                "queries": "list[str] - list of queries terms for searching PubMed."
-            },
-            output_type="list - List of items matching the search query. Each item consists of the title, abstract, keywords, and URL of the article. If no results found, a string message is returned.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(queries=["scoliosis", "injury"])',
-                    "description": "Search for PubMed articles mentioning 'scoliosis' OR 'injury'."
-                },
-                {
-                    "command": 'execution = tool.execute(queries=["COVID", "vaccine", "occupational health"])',
-                    "description": "Search for PubMed articles mentioning 'COVID' OR 'vaccine' OR 'occupational health'."
-                }
-            ],
-            user_metadata={
-                'limitations': "Try to use shorter and more general search queries."
-            }
-        )
-        self.pubmed = PubMed(tool="MyTool", email="[email protected]")
-        self.fetch = PubMedFetcher()
-
-    @retry(wait=wait_random_exponential(min=1, max=10), stop=stop_after_attempt(3))
-    def search_query(self, query_str, max_results=10):
-        return self.pubmed.query(query_str, max_results=max_results)
-
-    def execute(self, queries, max_results=10):
-        try:
-            query_str = f"({'[Title/Abstract] OR '.join(queries) + '[Title/Abstract]'}) AND hasabstract[All Fields] AND fha[Filter]"
-            max_results = min(max_results, 50)
-
-            results = self.search_query(query_str, max_results=max_results) # API can only get most recent
-
-            items = []
-            for article in results:
-                try:
-                    article = json.loads(article.toJSON())
-                    pubmed_id = article['pubmed_id'] # get id using pymed then get content using metapub
-
-                    article = self.fetch.article_by_pmid(pubmed_id)
-                    items.append({
-                        'title': article.title,
-                        'abstract': article.abstract,
-                        'keywords': article.keywords,
-                        'url': article.url
-                    })
-                except:
-                    continue
-
-            if len(items) == 0:
-                return "No results found for search query. Try another query or tool."
-            
-            return items
-        
-        except Exception as e:
-            print(f"Error searching PubMed: {e}")
-            return []
-
-    def get_metadata(self):
-        metadata = super().get_metadata()
-        return metadata
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools/tools/pubmed_search
-    python tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage
-    tool = Pubmed_Search_Tool()
-
-    # Queries
-    queries = ["COVID occupational health"]
-
-    # Execute the tool
-    try:
-        execution = tool.execute(queries=queries)
-        print(execution)
-    except ValueError as e: 
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/python_code_generator/test.log

@@ -1,13 +0,0 @@
-
-Initializing Python_Code_Generator_Tool with model_string: gpt-4o-mini
-!! Cache enabled for model: gpt-4o-mini
-
-Initializing Python_Code_Generator_Tool with model_string: gpt-4o-mini
-!! Cache enabled for model: gpt-4o-mini
-{'tool_name': 'Python_Code_Generator_Tool', 'tool_description': 'A tool that generates and executes simple Python code snippets for basic arithmetical calculations and math-related problems. The generated code runs in a highly restricted environment with only basic mathematical operations available.', 'tool_version': '1.0.0', 'input_types': {'query': 'str - A clear, specific description of the arithmetic calculation or math problem to be solved, including any necessary numerical inputs.'}, 'output_type': 'dict - A dictionary containing the generated code, calculation result, and any error messages.', 'demo_commands': [{'command': 'execution = tool.execute(query="Calculate the factorial of 5")', 'description': 'Generate a Python code snippet to calculate the factorial of 5.'}, {'command': 'execution = tool.execute(query="Find the sum of prime numbers up to 50")', 'description': 'Generate a Python code snippet to find the sum of prime numbers up to 50.'}, {'command': 'query="Given the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], calculate the sum of squares of odd numbers"\nexecution = tool.execute(query=query)', 'description': 'Generate a Python function for a specific mathematical operation on a given list of numbers.'}], 'require_llm_engine': True, 'user_metadata': {'limitations': ['Restricted to basic Python arithmetic operations and built-in mathematical functions.', 'Cannot use any external libraries or modules, including those in the Python standard library.', 'Limited to simple mathematical calculations and problems.', 'Cannot perform any string processing, data structure manipulation, or complex algorithms.', 'No access to any system resources, file operations, or network requests.', "Cannot use 'import' statements.", 'All calculations must be self-contained within a single function or script.', 'Input must be provided directly in the query string.', 'Output is limited to numerical results or simple lists/tuples of numbers.'], 'best_practices': ['Provide clear and specific queries that describe the desired mathematical calculation.', 'Include all necessary numerical inputs directly in the query string.', 'Keep tasks focused on basic arithmetic, algebraic calculations, or simple mathematical algorithms.', 'Ensure all required numerical data is included in the query.', 'Verify that the query only involves mathematical operations and does not require any data processing or complex algorithms.', 'Review generated code to ensure it only uses basic Python arithmetic operations and built-in math functions.']}}
-
-###Query: Given the number list: [1, 2, 3, 4, 5], calculate the sum of all the numbers in the list.
-The sum of all the numbers in the list [1, 2, 3, 4, 5] is: 15
-
-###Execution Result: {'printed_output': 'The sum of all the numbers in the list [1, 2, 3, 4, 5] is: 15', 'variables': {'numbers': [1, 2, 3, 4, 5], 'total_sum': 15}}
-Done!

octotools/tools/python_code_generator/tool.py

@@ -1,243 +0,0 @@
-# octotools/tools/python_code_generator/tool.py
-
-import os
-import re
-import sys
-from io import StringIO
-import contextlib
-
-
-from octotools.tools.base import BaseTool
-from octotools.engine.openai import ChatOpenAI
-
-import signal
-from contextlib import contextmanager
-
-# Custom exception for code execution timeout
-class TimeoutException(Exception):
-    pass
-
-# Custom context manager for code execution timeout
-@contextmanager
-def timeout(seconds):
-    def timeout_handler(signum, frame):
-        raise TimeoutException("Code execution timed out")
-
-    # Set the timeout handler
-    original_handler = signal.signal(signal.SIGALRM, timeout_handler)
-    signal.alarm(seconds)
-    
-    try:
-        yield
-    finally:
-        # Restore the original handler and disable the alarm
-        signal.alarm(0)
-        signal.signal(signal.SIGALRM, original_handler)
-
-
-class Python_Code_Generator_Tool(BaseTool):
-    require_llm_engine = True
-
-    def __init__(self, model_string="gpt-4o-mini"):
-        super().__init__(
-            tool_name="Python_Code_Generator_Tool",
-            tool_description="A tool that generates and executes simple Python code snippets for basic arithmetical calculations and math-related problems. The generated code runs in a highly restricted environment with only basic mathematical operations available.",
-            tool_version="1.0.0",
-            input_types={
-                "query": "str - A clear, specific description of the arithmetic calculation or math problem to be solved, including any necessary numerical inputs."},
-            output_type="dict - A dictionary containing the generated code, calculation result, and any error messages.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(query="Calculate the factorial of 5")',
-                    "description": "Generate a Python code snippet to calculate the factorial of 5."
-                },
-                {
-                    "command": 'execution = tool.execute(query="Find the sum of prime numbers up to 50")',
-                    "description": "Generate a Python code snippet to find the sum of prime numbers up to 50."
-                },
-                {
-                    "command": 'query="Given the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], calculate the sum of squares of odd numbers"\nexecution = tool.execute(query=query)',
-                    "description": "Generate a Python function for a specific mathematical operation on a given list of numbers."
-                },
-            ],
-            user_metadata = {
-                "limitations": [
-                    "Restricted to basic Python arithmetic operations and built-in mathematical functions.",
-                    "Cannot use any external libraries or modules, including those in the Python standard library.",
-                    "Limited to simple mathematical calculations and problems.",
-                    "Cannot perform any string processing, data structure manipulation, or complex algorithms.",
-                    "No access to any system resources, file operations, or network requests.",
-                    "Cannot use 'import' statements.",
-                    "All calculations must be self-contained within a single function or script.",
-                    "Input must be provided directly in the query string.",
-                    "Output is limited to numerical results or simple lists/tuples of numbers."
-                ],
-                "best_practices": [
-                    "Provide clear and specific queries that describe the desired mathematical calculation.",
-                    "Include all necessary numerical inputs directly in the query string.",
-                    "Keep tasks focused on basic arithmetic, algebraic calculations, or simple mathematical algorithms.",
-                    "Ensure all required numerical data is included in the query.",
-                    "Verify that the query only involves mathematical operations and does not require any data processing or complex algorithms.",
-                    "Review generated code to ensure it only uses basic Python arithmetic operations and built-in math functions."
-                ]
-            }
-        )
-        print(f"\nInitializing Python_Code_Generator_Tool with model_string: {model_string}")
-        self.llm_engine = ChatOpenAI(model_string=model_string, is_multimodal=False) if model_string else None
-
-    @staticmethod
-    def preprocess_code(code):
-        """
-        Preprocesses the generated code snippet by extracting it from the response.
-
-        Parameters:
-            code (str): The response containing the code snippet.
-
-        Returns:
-            str: The extracted code snippet.
-        """
-        code = re.search(r"```python(.*)```", code, re.DOTALL).group(1).strip()
-        return code
-
-    @contextlib.contextmanager
-    def capture_output(self):
-        """
-        Context manager to capture the standard output.
-
-        Yields:
-            StringIO: The captured output.
-        """
-        new_out = StringIO()
-        old_out = sys.stdout
-        sys.stdout = new_out
-        try:
-            yield sys.stdout
-        finally:
-            sys.stdout = old_out
-
-    def execute_code_snippet(self, code):
-        """
-        Executes the given Python code snippet.
-
-        Parameters:
-            code (str): The Python code snippet to be executed.
-
-        Returns:
-            dict: A dictionary containing the printed output and local variables.
-        """
-        # Check for dangerous functions and remove them
-        dangerous_functions = ['exit', 'quit', 'sys.exit']
-        for func in dangerous_functions:
-            if func in code:
-                print(f"Warning: Removing unsafe '{func}' call from code")
-                # Use regex to remove function calls with any arguments
-                code = re.sub(rf'{func}\s*\([^)]*\)', 'break', code)
-
-        try:
-            execution_code = self.preprocess_code(code)
-
-            # Execute with 10-second timeout
-            with timeout(10):
-                try:
-                    exec(execution_code)
-                except TimeoutException:
-                    print("Error: Code execution exceeded 60 seconds timeout")
-                    return {"error": "Execution timed out after 60 seconds"}
-                except Exception as e:
-                    print(f"Error executing code: {e}")
-                    return {"error": str(e)}
-                
-            # Capture the output and local variables
-            local_vars = {}
-            with self.capture_output() as output:
-                exec(execution_code, {}, local_vars)
-            printed_output = output.getvalue().strip()
-
-            # Filter out built-in variables and modules
-            """
-            only the variables used in the code are returned, 
-            excluding built-in variables (which start with '__') and imported modules.
-            """
-            used_vars = {k: v for k, v in local_vars.items() 
-                         if not k.startswith('__') and not isinstance(v, type(sys))}
-            
-            return {"printed_output": printed_output, "variables": used_vars}
-        
-        except Exception as e:
-            print(f"Error executing code: {e}")
-            return {"error": str(e)}
-
-    def execute(self, query):
-        """
-        Generates and executes Python code based on the provided query.
-
-        Parameters:
-            query (str): A query describing the desired operation.
-
-        Returns:
-            dict: A dictionary containing the executed output, local variables, or any error message.
-        """
-
-        if not self.llm_engine:
-            raise ValueError("LLM engine not initialized. Please provide a valid model_string when initializing the tool.")
-
-        task_description = """
-        Given a query, generate a Python code snippet that performs the specified operation on the provided data. Please think step by step. Ensure to break down the process into clear, logical steps. Make sure to print the final result in the generated code snippet with a descriptive message explaining what the output represents. The final output should be presented in the following format:
-
-        ```python
-        <code snippet>
-        ```
-        """
-        task_description = task_description.strip()
-        full_prompt = f"Task:\n{task_description}\n\nQuery:\n{query}"
-
-        response = self.llm_engine(full_prompt)
-        result_or_error = self.execute_code_snippet(response)
-        return result_or_error
-
-    def get_metadata(self):
-        """
-        Returns the metadata for the Python_Code_Generator_Tool.
-
-        Returns:
-            dict: A dictionary containing the tool's metadata.
-        """
-        metadata = super().get_metadata()
-        metadata["require_llm_engine"] = self.require_llm_engine # NOTE: can be removed if not needed
-        return metadata
-
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools/tools/python_code_generator
-    python tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the Python_Code_Generator_Tool
-    tool = Python_Code_Generator_Tool()
-    tool = Python_Code_Generator_Tool(model_string="gpt-4o-mini")
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Sample query for generating and executing Python code
-    queries = [
-        "Given the number list: [1, 2, 3, 4, 5], calculate the sum of all the numbers in the list.",
-    ]
-    for query in queries:
-        print(f"\n###Query: {query}")
-        # Execute the tool with the sample query
-        try:
-            execution = tool.execute(query=query)
-            print("\n###Execution Result:", execution)
-        except ValueError as e:
-            print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/relevant_patch_zoomer/test.log

@@ -1,10 +0,0 @@
-
-Initializing Patch Zoomer Tool with model: gpt-4o
-!! Cache enabled for model: gpt-4o
-{'tool_name': 'Relevant_Patch_Zoomer_Tool', 'tool_description': 'A tool that analyzes an image, divides it into 5 regions (4 quarters + center), and identifies the most relevant patches based on a question. The returned patches are zoomed in by a factor of 2.', 'tool_version': '1.0.0', 'input_types': {'image': 'str - The path to the image file.', 'question': 'str - The question about the image content.'}, 'output_type': 'dict - Contains analysis text and list of saved zoomed patch paths.', 'demo_commands': [{'command': 'execution = tool.execute(image="path/to/image.jpg", question="What is the color of the car?")', 'description': "Analyze image and return relevant zoomed patches that show the car's color."}], 'require_llm_engine': True, 'user_metadata': {'best_practices': ['It might be helpful to zoom in on the image first to get a better look at the object(s).', 'It might be helpful if the question requires a close-up view of the object(s), symbols, texts, etc.', 'The tool should be used to provide a high-level analysis first, and then use other tools for fine-grained analysis. For example, you can use Relevant_Patch_Zoomer_Tool first to get a zoomed patch of specific objects, and then use Image_Captioner_Tool to describe the objects in detail.']}}
-
-Detected Patches:
-Path: /root/Projects/octotools/octotools/tools/relevant_patch_zoomer/zoomed_patches/car_bottom-right_zoomed_2x.png
-Description: The bottom-right region of the image: /root/Projects/octotools/octotools/tools/relevant_patch_zoomer/examples/car.png.
-
-Done!

octotools/tools/relevant_patch_zoomer/tool.py

@@ -1,188 +0,0 @@
-import os
-import cv2
-from pydantic import BaseModel
-from octotools.tools.base import BaseTool
-from octotools.engine.openai import ChatOpenAI
-
-class PatchZoomerResponse(BaseModel):
-    analysis: str
-    patch: list[str]
-
-class Relevant_Patch_Zoomer_Tool(BaseTool):
-    require_llm_engine = True
-
-    def __init__(self, model_string="gpt-4o"):
-        super().__init__(
-            tool_name="Relevant_Patch_Zoomer_Tool",
-            tool_description="A tool that analyzes an image, divides it into 5 regions (4 quarters + center), and identifies the most relevant patches based on a question. The returned patches are zoomed in by a factor of 2.",
-            tool_version="1.0.0",
-            input_types={
-                "image": "str - The path to the image file.",
-                "question": "str - The question about the image content.",
-            },
-            output_type="dict - Contains analysis text and list of saved zoomed patch paths.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.jpg", question="What is the color of the car?")',
-                    "description": "Analyze image and return relevant zoomed patches that show the car's color."
-                }
-            ],
-            user_metadata = {
-                "best_practices": [
-                    "It might be helpful to zoom in on the image first to get a better look at the object(s).",
-                    "It might be helpful if the question requires a close-up view of the object(s), symbols, texts, etc.",
-                    "The tool should be used to provide a high-level analysis first, and then use other tools for fine-grained analysis. For example, you can use Relevant_Patch_Zoomer_Tool first to get a zoomed patch of specific objects, and then use Image_Captioner_Tool to describe the objects in detail."
-                ]
-            }
-        )
-        self.matching_dict = {
-            "A": "top-left",
-            "B": "top-right",
-            "C": "bottom-left",
-            "D": "bottom-right",
-            "E": "center"
-        }
-
-        print(f"\nInitializing Patch Zoomer Tool with model: {model_string}")
-        self.llm_engine = ChatOpenAI(model_string=model_string, is_multimodal=True) if model_string else None
-        
-    def _save_patch(self, image_path, patch, save_path, zoom_factor=2):
-        """Extract and save a specific patch from the image with 10% margins."""
-        img = cv2.imread(image_path)
-        height, width = img.shape[:2]
-        
-        quarter_h = height // 2
-        quarter_w = width // 2
-        
-        margin_h = int(quarter_h * 0.1)
-        margin_w = int(quarter_w * 0.1)
-        
-        patch_coords = {
-            'A': ((max(0, 0 - margin_w), max(0, 0 - margin_h)),
-                  (min(width, quarter_w + margin_w), min(height, quarter_h + margin_h))),
-            'B': ((max(0, quarter_w - margin_w), max(0, 0 - margin_h)),
-                  (min(width, width + margin_w), min(height, quarter_h + margin_h))),
-            'C': ((max(0, 0 - margin_w), max(0, quarter_h - margin_h)),
-                  (min(width, quarter_w + margin_w), min(height, height + margin_h))),
-            'D': ((max(0, quarter_w - margin_w), max(0, quarter_h - margin_h)),
-                  (min(width, width + margin_w), min(height, height + margin_h))),
-            'E': ((max(0, quarter_w//2 - margin_w), max(0, quarter_h//2 - margin_h)),
-                  (min(width, quarter_w//2 + quarter_w + margin_w), 
-                   min(height, quarter_h//2 + quarter_h + margin_h)))
-        }
-        
-        (x1, y1), (x2, y2) = patch_coords[patch]
-        patch_img = img[y1:y2, x1:x2]
-        
-        zoomed_patch = cv2.resize(patch_img, 
-                                (patch_img.shape[1] * zoom_factor, 
-                                 patch_img.shape[0] * zoom_factor), 
-                                interpolation=cv2.INTER_LINEAR)
-        
-        os.makedirs(os.path.dirname(save_path), exist_ok=True)
-        cv2.imwrite(save_path, zoomed_patch)
-        return save_path
-
-    def execute(self, image, question, zoom_factor=2):
-        try:
-            if not self.llm_engine:
-                return "Error: LLM engine not initialized. Please provide a valid model_string."
-            
-            # Prepare the prompt
-            prompt = f"""
-Analyze this image to identify the most relevant region(s) for answering the question:
-
-Question: {question}
-
-The image is divided into 5 regions:
-- (A) Top-left quarter
-- (B) Top-right quarter
-- (C) Bottom-left quarter
-- (D) Bottom-right quarter
-- (E) Center region (1/4 size, overlapping middle section)
-
-Instructions:
-1. First describe what you see in each of the five regions.
-2. Then select the most relevant region(s) to answer the question.
-3. Choose only the minimum necessary regions - avoid selecting redundant areas that show the same content. For example, if one patch contains the entire object(s), do not select another patch that only shows a part of the same object(s).
-
-
-Response format:
-<analysis>: Describe the image and five patches first. Then analyze the question and select the most relevant patch or list of patches.
-<patch>: List of letters (A-E)
-"""
-            # Read image and create input data
-            with open(image, 'rb') as file:
-                image_bytes = file.read()
-            input_data = [prompt, image_bytes]
-            
-            # Get response from LLM
-            response = self.llm_engine(input_data, response_format=PatchZoomerResponse)
-            
-            # Save patches
-            image_dir = os.path.dirname(image)
-            image_name = os.path.splitext(os.path.basename(image))[0]
-            
-            # Update the return structure
-            patch_info = []
-            for patch in response.patch:
-                patch_name = self.matching_dict[patch]
-                save_path = os.path.join(self.output_dir, 
-                                       f"{image_name}_{patch_name}_zoomed_{zoom_factor}x.png")
-                saved_path = self._save_patch(image, patch, save_path, zoom_factor)
-                save_path = os.path.abspath(saved_path)
-                patch_info.append({
-                    "path": save_path,
-                    "description": f"The {self.matching_dict[patch]} region of the image: {image}."
-                })
-            
-            return {
-                "analysis": response.analysis,
-                "patches": patch_info
-            }
-            
-        except Exception as e:
-            print(f"Error in patch zooming: {e}")
-            return None
-
-    def get_metadata(self):
-        return super().get_metadata()
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools/tools/relevant_patch_zoomer
-    python tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the Relevant_Patch_Zoomer_Tool
-    tool = Relevant_Patch_Zoomer_Tool()
-    tool.set_custom_output_dir(f"{script_dir}/zoomed_patches")
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Construct the full path to the image using the script's directory
-    relative_image_path = "examples/car.png"
-    image_path = os.path.join(script_dir, relative_image_path)
-    question = "What is the color of the car?"
-
-    # Execute the tool
-    try:
-        result = tool.execute(image=image_path, question=question)
-        if result:
-            print("\nDetected Patches:")
-            for patch in result['patches']:
-                print(f"Path: {patch['path']}")
-                print(f"Description: {patch['description']}")
-                print()
-    except Exception as e:
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/text_detector/test.log

@@ -1,4 +0,0 @@
-{'tool_name': 'Text_Detector_Tool', 'tool_description': 'A tool that detects text in an image using EasyOCR.', 'tool_version': '1.0.0', 'input_types': {'image': 'str - The path to the image file.', 'languages': 'list - A list of language codes for the OCR model.', 'detail': 'int - The level of detail in the output. Set to 0 for simpler output, 1 for detailed output.'}, 'output_type': 'list - A list of detected text blocks.', 'demo_commands': [{'command': 'execution = tool.execute(image="path/to/image.png", languages=["en"])', 'description': 'Detect text in an image using the default language (English).'}, {'command': 'execution = tool.execute(image="path/to/image.png", languages=["en", "de"])', 'description': 'Detect text in an image using multiple languages (English and German).'}, {'command': 'execution = tool.execute(image="path/to/image.png", languages=["en"], detail=0)', 'description': 'Detect text in an image with simpler output (text without coordinates and scores).'}], 'require_llm_engine': False, 'user_metadata': {'frequently_used_language': {'ch_sim': 'Simplified Chinese', 'ch_tra': 'Traditional Chinese', 'de': 'German', 'en': 'English', 'es': 'Spanish', 'fr': 'French', 'hi': 'Hindi', 'ja': 'Japanese'}}}
-[[[[231, 32], [674, 32], [674, 64], [231, 64]], "Reduce your risk of coronavirus infection:", 0.84], [[[326, 98], [598, 98], [598, 124], [326, 124]], "Clean hands with soap and water", 0.96], [[[328, 124], [542, 124], [542, 148], [328, 148]], "or alcohol-based hand rub", 0.89], [[[246, 169], [595, 169], [595, 196], [246, 196]], "Cover nose and mouth when coughing and", 1.0], [[[245, 194], [546, 194], [546, 222], [245, 222]], "sneezing with tissue or flexed elbow", 0.96], [[[320, 240], [624, 240], [624, 266], [320, 266]], "Avoid close contact with anyone with", 0.86], [[[318, 266], [528, 266], [528, 292], [318, 292]], "cold or flu-like symptoms", 0.77], [[[248, 322], [510, 322], [510, 348], [248, 348]], "Thoroughly cook meat and eggs", 0.72], [[[332, 370], [640, 370], [640, 396], [332, 396]], "No unprotected contact with live wild", 0.83], [[[334, 396], [464, 396], [464, 420], [334, 420]], "or farm animals", 0.72], [[[595, 427], [683, 427], [683, 447], [595, 447]], "World Health", 1.0], [[[595, 445], [685, 445], [685, 463], [595, 463]], "Organization", 1.0]]
-Detected Text: [([[231, 32], [674, 32], [674, 64], [231, 64]], 'Reduce your risk of coronavirus infection:', 0.84), ([[326, 98], [598, 98], [598, 124], [326, 124]], 'Clean hands with soap and water', 0.96), ([[328, 124], [542, 124], [542, 148], [328, 148]], 'or alcohol-based hand rub', 0.89), ([[246, 169], [595, 169], [595, 196], [246, 196]], 'Cover nose and mouth when coughing and', 1.0), ([[245, 194], [546, 194], [546, 222], [245, 222]], 'sneezing with tissue or flexed elbow', 0.96), ([[320, 240], [624, 240], [624, 266], [320, 266]], 'Avoid close contact with anyone with', 0.86), ([[318, 266], [528, 266], [528, 292], [318, 292]], 'cold or flu-like symptoms', 0.77), ([[248, 322], [510, 322], [510, 348], [248, 348]], 'Thoroughly cook meat and eggs', 0.72), ([[332, 370], [640, 370], [640, 396], [332, 396]], 'No unprotected contact with live wild', 0.83), ([[334, 396], [464, 396], [464, 420], [334, 420]], 'or farm animals', 0.72), ([[595, 427], [683, 427], [683, 447], [595, 447]], 'World Health', 1.0), ([[595, 445], [685, 445], [685, 463], [595, 463]], 'Organization', 1.0)]
-Done!

octotools/tools/text_detector/tool.py

@@ -1,173 +0,0 @@
-# octotools/tools/text_detector/tool.py
-
-import os
-import time
-from octotools.tools.base import BaseTool
-
-import warnings
-warnings.filterwarnings("ignore")
-
-class Text_Detector_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="Text_Detector_Tool",
-            tool_description="A tool that detects text in an image using EasyOCR.",
-            tool_version="1.0.0",
-            input_types={
-                "image": "str - The path to the image file.",
-                "languages": "list - A list of language codes for the OCR model.",
-                "detail": "int - The level of detail in the output. Set to 0 for simpler output, 1 for detailed output."
-            },
-            output_type="list - A list of detected text blocks.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png", languages=["en"])',
-                    "description": "Detect text in an image using the default language (English)."
-                },
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png", languages=["en", "de"])',
-                    "description": "Detect text in an image using multiple languages (English and German)."
-                },
-                {
-                    "command": 'execution = tool.execute(image="path/to/image.png", languages=["en"], detail=0)',
-                    "description": "Detect text in an image with simpler output (text without coordinates and scores)."
-                },
-            ],
-            user_metadata={
-                "frequently_used_language": {
-                    "ch_sim": "Simplified Chinese",
-                    "ch_tra": "Traditional Chinese",
-                    "de": "German",
-                    "en": "English",
-                    "es": "Spanish",
-                    "fr": "French",
-                    "hi": "Hindi",
-                    "ja": "Japanese",
-                }
-            }
-        )
-
-    def build_tool(self, languages=None):
-        """
-        Builds and returns the EasyOCR reader model.
-
-        Parameters:
-            languages (list): A list of language codes for the OCR model.
-
-        Returns:
-            easyocr.Reader: An initialized EasyOCR Reader object.
-        """
-        languages = languages or ["en"]  # Default to English if no languages provided
-        try:
-            import easyocr
-            reader = easyocr.Reader(languages)
-            return reader
-        except ImportError:
-            raise ImportError("Please install the EasyOCR package using 'pip install easyocr'.")
-        except Exception as e:
-            print(f"Error building the OCR tool: {e}")
-            return None
-    
-    def execute(self, image, languages=None, max_retries=10, retry_delay=5, clear_cuda_cache=False, **kwargs):
-        """
-        Executes the OCR tool to detect text in the provided image.
-
-        Parameters:
-            image (str): The path to the image file.
-            languages (list): A list of language codes for the OCR model.
-            max_retries (int): Maximum number of retry attempts.
-            retry_delay (int): Delay in seconds between retry attempts.
-            clear_cuda_cache (bool): Whether to clear CUDA cache on out-of-memory errors.
-            **kwargs: Additional keyword arguments for the OCR reader.
-
-        Returns:
-            list: A list of detected text blocks.
-        """
-        languages = languages or ["en"]
-
-        for attempt in range(max_retries):
-            try:
-                reader = self.build_tool(languages)
-                if reader is None:
-                    raise ValueError("Failed to build the OCR tool.")
-                
-                result = reader.readtext(image, **kwargs)
-                try:
-                    # detail = 1: Convert numpy types to standard Python types
-                    cleaned_result = [
-                        ([[int(coord[0]), int(coord[1])] for coord in item[0]], item[1], round(float(item[2]), 2))
-                        for item in result
-                    ]
-                    return cleaned_result
-                except Exception as e:
-                    # detail = 0
-                    return result
-
-            except RuntimeError as e:
-                if "CUDA out of memory" in str(e):
-                    print(f"CUDA out of memory error on attempt {attempt + 1}.")
-                    if clear_cuda_cache:
-                        print("Clearing CUDA cache and retrying...")
-                        torch.cuda.empty_cache()
-                    else:
-                        print(f"Retrying in {retry_delay} seconds...")
-                    time.sleep(retry_delay)
-                    continue
-                else:
-                    print(f"Runtime error: {e}")
-                    break
-            except Exception as e:
-                print(f"Error detecting text: {e}")
-                break
-        
-        print(f"Failed to detect text after {max_retries} attempts.")
-        return []
-
-    def get_metadata(self):
-        """
-        Returns the metadata for the Text_Detector_Tool.
-
-        Returns:
-            dict: A dictionary containing the tool's metadata.
-        """
-        metadata = super().get_metadata()
-        return metadata
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-    
-    cd octotools/tools/text_detector
-    python tool.py
-    """
-    import json
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the Text_Detector_Tool
-    tool = Text_Detector_Tool()
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Construct the full path to the image using the script's directory
-    # relative_image_path = "examples/chinese_tra.jpg"
-    # relative_image_path = "examples/chinese.jpg"
-    relative_image_path = "examples/english.png"
-    image_path = os.path.join(script_dir, relative_image_path)
-
-    # Execute the tool
-    try:
-        # execution = tool.execute(image=image_path, languages=["en", "ch_sim"])
-        # execution = tool.execute(image=image_path, languages=["en", "ch_tra"])
-        execution = tool.execute(image=image_path, languages=["en"])
-        print(json.dumps(execution))
-
-        print("Detected Text:", execution)
-    except ValueError as e:
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/url_text_extractor/test.log

@@ -1,770 +0,0 @@
-{'tool_name': 'URL_Text_Extractor_Tool', 'tool_description': 'A tool that extracts all text from a given URL.', 'tool_version': '1.0.0', 'input_types': {'url': 'str - The URL from which to extract text.'}, 'output_type': 'dict - A dictionary containing the extracted text and any error messages.', 'demo_commands': [{'command': 'execution = tool.execute(url="https://example.com")', 'description': 'Extract all text from the example.com website.'}, {'command': 'execution = tool.execute(url="https://en.wikipedia.org/wiki/Python_(programming_language)")', 'description': 'Extract all text from the Wikipedia page about Python programming language.'}], 'require_llm_engine': False}
-Execution Result:
-{
-    "url": "https://en.wikipedia.org/wiki/Python_(programming_language)",
-    "extracted_text": "Python (programming language) - Wikipedia\nJump to content\nMain menu\nMain menu\nmove to sidebar\nhide\nNavigation\nMain page\nContents\nCurrent events\nRandom article\nAbout Wikipedia\nContact us\nSpecial pages\nContribute\nHelp\nLearn to edit\nCommunity portal\nRecent changes\nUpload file\nSearch\nSearch\nAppearance\nDonate\nCreate account\nLog in\nPersonal tools\nDonate\nCreate account\nLog in\nPages for logged out editors\nlearn more\nContributions\nTalk\nContents\nmove to sidebar\nhide\n(Top)\n1\nHistory\n2\nDesign philosophy and features\n3\nSyntax and semantics\nToggle Syntax and semantics subsection\n3.1\nIndentation\n3.2\nStatements and control flow\n3.3\nExpressions\n3.4\nMethods\n3.5\nTyping\n3.6\nArithmetic operations\n3.7\nFunction syntax\n4\nProgramming examples\n5\nLibraries\n6\nDevelopment environments\n7\nImplementations\nToggle Implementations subsection\n7.1\nReference implementation\n7.2\nOther implementations\n7.3\nNo longer supported implementations\n7.4\nCross-compilers to other languages\n7.5\nPerformance\n8\nDevelopment\n9\nAPI documentation generators\n10\nNaming\n11\nPopularity\n12\nUses\n13\nLanguages influenced by Python\n14\nSee also\n15\nReferences\nToggle References subsection\n15.1\nSources\n16\nFurther reading\n17\nExternal links\nToggle the table of contents\nPython (programming language)\n112 languages\nAfrikaans\nAlemannisch\n\u0627\u0644\u0639\u0631\u0628\u064a\u0629\nAragon\u00e9s\n\u0985\u09b8\u09ae\u09c0\u09af\u09bc\u09be\nAsturianu\nAz\u0259rbaycanca\n\u062a\u06c6\u0631\u06a9\u062c\u0647\nBasa Bali\n\u09ac\u09be\u0982\u09b2\u09be\n\u95a9\u5357\u8a9e / B\u00e2n-l\u00e2m-g\u00fa\n\u0411\u0435\u043b\u0430\u0440\u0443\u0441\u043a\u0430\u044f\n\u0411\u0435\u043b\u0430\u0440\u0443\u0441\u043a\u0430\u044f (\u0442\u0430\u0440\u0430\u0448\u043a\u0435\u0432\u0456\u0446\u0430)\n\u092d\u094b\u091c\u092a\u0941\u0930\u0940\n\u0411\u044a\u043b\u0433\u0430\u0440\u0441\u043a\u0438\nBosanski\nBrezhoneg\nCatal\u00e0\nCebuano\n\u010ce\u0161tina\nCymraeg\nDansk\nDeutsch\nEesti\n\u0395\u03bb\u03bb\u03b7\u03bd\u03b9\u03ba\u03ac\nEspa\u00f1ol\nEsperanto\nEuskara\n\u0641\u0627\u0631\u0633\u06cc\nFran\u00e7ais\nGalego\n\u0a97\u0ac1\u0a9c\u0ab0\u0abe\u0aa4\u0ac0\n\ud55c\uad6d\uc5b4\nHausa\n\u0540\u0561\u0575\u0565\u0580\u0565\u0576\n\u0939\u093f\u0928\u094d\u0926\u0940\nHrvatski\nIdo\nBahasa Indonesia\nInterlingua\n\u00cdslenska\nItaliano\n\u05e2\u05d1\u05e8\u05d9\u05ea\n\u10e5\u10d0\u10e0\u10d7\u10e3\u10da\u10d8\n\u049a\u0430\u0437\u0430\u049b\u0448\u0430\nKiswahili\nKurd\u00ee\n\u041a\u044b\u0440\u0433\u044b\u0437\u0447\u0430\n\u0ea5\u0eb2\u0ea7\nLatina\nLatvie\u0161u\nLietuvi\u0173\nLa .lojban.\nLombard\nMagyar\n\u041c\u0430\u043a\u0435\u0434\u043e\u043d\u0441\u043a\u0438\n\u0d2e\u0d32\u0d2f\u0d3e\u0d33\u0d02\n\u092e\u0930\u093e\u0920\u0940\nBahasa Melayu\n\u041c\u043e\u043d\u0433\u043e\u043b\n\u1019\u103c\u1014\u103a\u1019\u102c\u1018\u102c\u101e\u102c\nNa Vosa Vakaviti\nNederlands\n\u0928\u0947\u092a\u093e\u0932\u0940\n\u65e5\u672c\u8a9e\n\u07d2\u07de\u07cf\nNorsk bokm\u00e5l\nNorsk nynorsk\n\u0b13\u0b21\u0b3c\u0b3f\u0b06\nO\u02bbzbekcha / \u045e\u0437\u0431\u0435\u043a\u0447\u0430\n\u0a2a\u0a70\u0a1c\u0a3e\u0a2c\u0a40\n\u067e\u0646\u062c\u0627\u0628\u06cc\n\u1797\u17b6\u179f\u17b6\u1781\u17d2\u1798\u17c2\u179a\nPlattd\u00fc\u00fctsch\nPolski\nPortugu\u00eas\nQaraqalpaqsha\nRom\u00e2n\u0103\nRuna Simi\n\u0420\u0443\u0441\u0441\u043a\u0438\u0439\n\u0421\u0430\u0445\u0430 \u0442\u044b\u043b\u0430\n\u1c65\u1c5f\u1c71\u1c5b\u1c5f\u1c72\u1c64\nScots\nShqip\n\u0dc3\u0dd2\u0d82\u0dc4\u0dbd\nSimple English\nSloven\u010dina\nSloven\u0161\u010dina\n\u06a9\u0648\u0631\u062f\u06cc\n\u0421\u0440\u043f\u0441\u043a\u0438 / srpski\nSrpskohrvatski / \u0441\u0440\u043f\u0441\u043a\u043e\u0445\u0440\u0432\u0430\u0442\u0441\u043a\u0438\nSuomi\nSvenska\nTagalog\n\u0ba4\u0bae\u0bbf\u0bb4\u0bcd\n\u0422\u0430\u0442\u0430\u0440\u0447\u0430 / tatar\u00e7a\n\u107d\u1083\u1087\u101e\u1083\u1087\u1010\u1086\u1038\n\u0c24\u0c46\u0c32\u0c41\u0c17\u0c41\n\u0e44\u0e17\u0e22\n\u0422\u043e\u04b7\u0438\u043a\u04e3\nT\u00fcrk\u00e7e\nBasa Ugi\n\u0423\u043a\u0440\u0430\u0457\u043d\u0441\u044c\u043a\u0430\n\u0627\u0631\u062f\u0648\n\u0626\u06c7\u064a\u063a\u06c7\u0631\u0686\u06d5 / Uyghurche\nTi\u1ebfng Vi\u1ec7t\nWalon\n\u6587\u8a00\nWinaray\n\u5434\u8bed\n\u7cb5\u8a9e\n\u4e2d\u6587\nEdit links\nArticle\nTalk\nEnglish\nRead\nEdit\nView history\nTools\nTools\nmove to sidebar\nhide\nActions\nRead\nEdit\nView history\nGeneral\nWhat links here\nRelated changes\nUpload file\nPermanent link\nPage information\nCite this page\nGet shortened URL\nDownload QR code\nPrint/export\nDownload as PDF\nPrintable version\nIn other projects\nWikimedia Commons\nMediaWiki\nWikibooks\nWikifunctions\nWikiquote\nWikiversity\nWikidata item\nAppearance\nmove to sidebar\nhide\nFrom Wikipedia, the free encyclopedia\nGeneral-purpose programming language\nPython\nParadigm\nMulti-paradigm\n:\nobject-oriented\n,\n[\n1\n]\nprocedural\n(\nimperative\n),\nfunctional\n,\nstructured\n,\nreflective\nDesigned\u00a0by\nGuido van Rossum\nDeveloper\nPython Software Foundation\nFirst\u00a0appeared\n20\u00a0February 1991\n; 33 years ago\n(\n1991-02-20\n)\n[\n2\n]\nStable release\n3.13.2\n   / 4 February 2025\n; 10 days ago\n(\n4 February 2025\n)\nTyping discipline\nduck\n,\ndynamic\n,\nstrong\n;\n[\n3\n]\noptional type annotations\n(since 3.5, but those hints are ignored, except with unofficial tools)\n[\n4\n]\nOS\nTier 1\n: 64-bit\nLinux\n,\nmacOS\n; 64- and 32-bit\nWindows\n10+\n[\n5\n]\nTier 2\n: E.g. 32-bit\nWebAssembly\n(WASI)\nTier 3\n: 64-bit\nAndroid\n,\n[\n6\n]\niOS\n,\nFreeBSD\n, and (32-bit)\nRaspberry Pi OS\nUnofficial (or has been known to work): Other\nUnix-like\n/\nBSD\nvariants) and a few other platforms\n[\n7\n]\n[\n8\n]\n[\n9\n]\nLicense\nPython Software Foundation License\nFilename extensions\n.py, .pyw, .pyz,\n[\n10\n]\n.pyi, .pyc, .pyd\nWebsite\npython.org\nMajor\nimplementations\nCPython\n,\nPyPy\n,\nStackless Python\n,\nMicroPython\n,\nCircuitPython\n,\nIronPython\n,\nJython\nDialects\nCython\n,\nRPython\n,\nStarlark\n[\n11\n]\nInfluenced by\nABC\n,\n[\n12\n]\nAda\n,\n[\n13\n]\nALGOL 68\n,\n[\n14\n]\nAPL\n,\n[\n15\n]\nC\n,\n[\n16\n]\nC++\n,\n[\n17\n]\nCLU\n,\n[\n18\n]\nDylan\n,\n[\n19\n]\nHaskell\n,\n[\n20\n]\n[\n15\n]\nIcon\n,\n[\n21\n]\nLisp\n,\n[\n22\n]\nModula-3\n,\n[\n14\n]\n[\n17\n]\nPerl\n,\n[\n23\n]\nStandard ML\n[\n15\n]\nInfluenced\nApache Groovy\n,\nBoo\n,\nCobra\n,\nCoffeeScript\n,\n[\n24\n]\nD\n,\nF#\n,\nGDScript\n,\nGo\n,\nJavaScript\n,\n[\n25\n]\n[\n26\n]\nJulia\n,\n[\n27\n]\nMojo\n,\n[\n28\n]\nNim\n,\nRing\n,\n[\n29\n]\nRuby\n,\n[\n30\n]\nSwift\n,\n[\n31\n]\nV\n[\n32\n]\nPython Programming\nat Wikibooks\nPython\nis a\nhigh-level\n,\ngeneral-purpose programming language\n. Its design philosophy emphasizes\ncode readability\nwith the use of\nsignificant indentation\n.\n[\n33\n]\nPython is\ndynamically type-checked\nand\ngarbage-collected\n. It supports multiple\nprogramming paradigms\n, including\nstructured\n(particularly\nprocedural\n),\nobject-oriented\nand\nfunctional programming\n. It is often described as a \"batteries included\" language due to its comprehensive\nstandard library\n.\n[\n34\n]\n[\n35\n]\nGuido van Rossum\nbegan working on Python in the late 1980s as a successor to the\nABC\nprogramming language and first released it in 1991 as Python\u00a00.9.0.\n[\n36\n]\nPython\u00a02.0 was released in 2000. Python\u00a03.0, released in 2008, was a major revision not completely\nbackward-compatible\nwith earlier versions. Python\u00a02.7.18, released in 2020, was the last release of Python\u00a02.\n[\n37\n]\nPython consistently ranks as one of the most popular programming languages, and has gained widespread use in the\nmachine learning\ncommunity.\n[\n38\n]\n[\n39\n]\n[\n40\n]\n[\n41\n]\nHistory\n[\nedit\n]\nMain article:\nHistory of Python\nThe designer of Python,\nGuido van Rossum\n, at PyCon US 2024\nPython was conceived in the late 1980s\n[\n42\n]\nby\nGuido van Rossum\nat\nCentrum Wiskunde & Informatica\n(CWI) in the\nNetherlands\nas a successor to the\nABC\nprogramming language, which was inspired by\nSETL\n,\n[\n43\n]\ncapable of\nexception handling\nand interfacing with the\nAmoeba\noperating system.\n[\n12\n]\nIts implementation began in December\u00a01989.\n[\n44\n]\nVan Rossum shouldered sole responsibility for the project, as the lead developer, until 12 July 2018, when he announced his \"permanent vacation\" from his responsibilities as Python's \"\nbenevolent dictator for life\n\" (BDFL), a title the Python community bestowed upon him to reflect his long-term commitment as the project's chief decision-maker\n[\n45\n]\n(he has since come out of retirement and is self-titled \"BDFL-emeritus\"). In January\u00a02019, active Python core developers elected a five-member Steering Council to lead the project.\n[\n46\n]\n[\n47\n]\nThe name Python is said to come from the British comedy series\nMonty Python's Flying Circus\n.\n[\n48\n]\nPython 2.0 was released on 16 October 2000, with many major new features such as\nlist comprehensions\n,\ncycle-detecting\ngarbage collection,\nreference counting\n, and\nUnicode\nsupport.\n[\n49\n]\nPython 2.7's\nend-of-life\nwas initially set for 2015, then postponed to 2020 out of concern that a large body of existing code could not easily be forward-ported to Python\u00a03.\n[\n50\n]\n[\n51\n]\nNo further security patches or other improvements will be released for it.\n[\n52\n]\n[\n53\n]\nWhile Python 2.7 and older versions are officially unsupported, a different unofficial Python implementation,\nPyPy\n, continues to support Python 2, i.e. \"2.7.18+\" (plus 3.10), with the plus meaning (at least some) \"\nbackported\nsecurity updates\".\n[\n54\n]\nPython\u00a03.0 was released on 3 December 2008, with some new semantics and changed syntax. At least every Python release since (now unsupported) 3.5 has added some syntax to the language, and a few later releases have dropped outdated modules, or changed semantics, at least in a minor way.\nSince 7\u00a0October\u00a02024\n[update]\n, Python 3.13 is the latest stable release, and it and, for few more months, 3.12 are the only releases with active support including for bug fixes (as opposed to just for security) and Python 3.9,\n[\n55\n]\nis the oldest supported version of Python (albeit in the 'security support' phase), due to Python 3.8 reaching\nend-of-life\n.\n[\n56\n]\n[\n57\n]\nStarting with 3.13, it and later versions have 2 years of full support (up from one and a half), followed by 3 years of security support (for same total support as before).\nSecurity updates were expedited in 2021 (and again twice in 2022, and more fixed in 2023 and in September 2024 for Python 3.12.6 down to 3.8.20), since all Python versions were insecure (including 2.7\n[\n58\n]\n) because of security issues leading to possible\nremote code execution\n[\n59\n]\nand\nweb-cache poisoning\n.\n[\n60\n]\nPython 3.10 added the\n|\nunion type operator\n[\n61\n]\nand the\nmatch\nand\ncase\nkeywords (for structural\npattern matching\nstatements). 3.11 expanded\nexception handling\nfunctionality. Python 3.12 added the new keyword\ntype\n. Notable changes in 3.11 from 3.10 include increased program execution speed and improved error reporting.\n[\n62\n]\nPython 3.11 claims to be between 10 and 60% faster than Python 3.10, and Python 3.12 adds another 5% on top of that. It also has improved error messages (again improved in 3.14), and many other changes.\nPython 3.13 introduces more syntax for types, a new and improved interactive interpreter (\nREPL\n), featuring multi-line editing and color support; an incremental garbage collector (producing shorter pauses for collection in programs with a lot of objects, and addition to the improved speed in 3.11 and 3.12),  and an\nexperimental\njust-in-time (JIT) compiler\n(such features, can/needs to be enabled specifically for the increase in speed),\n[\n63\n]\nand an\nexperimental\nfree-threaded build mode, which disables the\nglobal interpreter lock\n(GIL), allowing threads to run more concurrently, that latter feature enabled with\npython3.13t\nor\npython3.13t.exe\n.\nPython 3.13 introduces some change in behavior, i.e. new \"well-defined semantics\", fixing bugs (plus many removals of deprecated classes, functions and methods, and removed some of the C\u00a0API and outdated modules): \"The  [old] implementation of\nlocals()\nand\nframe.f_locals\nis slow, inconsistent and buggy [and it] has many corner cases and oddities. Code that works around those may need to be changed. Code that uses\nlocals()\nfor simple templating, or print debugging, will continue to work corr"
-}
-url:
-https://en.wikipedia.org/wiki/Python_(programming_language)
-
-extracted_text:
-Python (programming language) - Wikipedia
-Jump to content
-Main menu
-Main menu
-move to sidebar
-hide
-Navigation
-Main page
-Contents
-Current events
-Random article
-About Wikipedia
-Contact us
-Special pages
-Contribute
-Help
-Learn to edit
-Community portal
-Recent changes
-Upload file
-Search
-Search
-Appearance
-Donate
-Create account
-Log in
-Personal tools
-Donate
-Create account
-Log in
-Pages for logged out editors
-learn more
-Contributions
-Talk
-Contents
-move to sidebar
-hide
-(Top)
-1
-History
-2
-Design philosophy and features
-3
-Syntax and semantics
-Toggle Syntax and semantics subsection
-3.1
-Indentation
-3.2
-Statements and control flow
-3.3
-Expressions
-3.4
-Methods
-3.5
-Typing
-3.6
-Arithmetic operations
-3.7
-Function syntax
-4
-Programming examples
-5
-Libraries
-6
-Development environments
-7
-Implementations
-Toggle Implementations subsection
-7.1
-Reference implementation
-7.2
-Other implementations
-7.3
-No longer supported implementations
-7.4
-Cross-compilers to other languages
-7.5
-Performance
-8
-Development
-9
-API documentation generators
-10
-Naming
-11
-Popularity
-12
-Uses
-13
-Languages influenced by Python
-14
-See also
-15
-References
-Toggle References subsection
-15.1
-Sources
-16
-Further reading
-17
-External links
-Toggle the table of contents
-Python (programming language)
-112 languages
-Afrikaans
-Alemannisch
-العربية
-Aragonés
-অসমীয়া
-Asturianu
-Azərbaycanca
-تۆرکجه
-Basa Bali
-বাংলা
-閩南語 / Bân-lâm-gú
-Беларуская
-Беларуская (тарашкевіца)
-भोजपुरी
-Български
-Bosanski
-Brezhoneg
-Català
-Cebuano
-Čeština
-Cymraeg
-Dansk
-Deutsch
-Eesti
-Ελληνικά
-Español
-Esperanto
-Euskara
-فارسی
-Français
-Galego
-ગુજરાતી
-한국어
-Hausa
-Հայերեն
-हिन्दी
-Hrvatski
-Ido
-Bahasa Indonesia
-Interlingua
-Íslenska
-Italiano
-עברית
-ქართული
-Қазақша
-Kiswahili
-Kurdî
-Кыргызча
-ລາວ
-Latina
-Latviešu
-Lietuvių
-La .lojban.
-Lombard
-Magyar
-Македонски
-മലയാളം
-मराठी
-Bahasa Melayu
-Монгол
-မြန်မာဘာသာ
-Na Vosa Vakaviti
-Nederlands
-नेपाली
-日本語
-ߒߞߏ
-Norsk bokmål
-Norsk nynorsk
-ଓଡ଼ିଆ
-Oʻzbekcha / ўзбекча
-ਪੰਜਾਬੀ
-پنجابی
-ភាសាខ្មែរ
-Plattdüütsch
-Polski
-Português
-Qaraqalpaqsha
-Română
-Runa Simi
-Русский
-Саха тыла
-ᱥᱟᱱᱛᱟᱲᱤ
-Scots
-Shqip
-සිංහල
-Simple English
-Slovenčina
-Slovenščina
-کوردی
-Српски / srpski
-Srpskohrvatski / српскохрватски
-Suomi
-Svenska
-Tagalog
-தமிழ்
-Татарча / tatarça
-ၽႃႇသႃႇတႆး
-తెలుగు
-ไทย
-Тоҷикӣ
-Türkçe
-Basa Ugi
-Українська
-اردو
-ئۇيغۇرچە / Uyghurche
-Tiếng Việt
-Walon
-文言
-Winaray
-吴语
-粵語
-中文
-Edit links
-Article
-Talk
-English
-Read
-Edit
-View history
-Tools
-Tools
-move to sidebar
-hide
-Actions
-Read
-Edit
-View history
-General
-What links here
-Related changes
-Upload file
-Permanent link
-Page information
-Cite this page
-Get shortened URL
-Download QR code
-Print/export
-Download as PDF
-Printable version
-In other projects
-Wikimedia Commons
-MediaWiki
-Wikibooks
-Wikifunctions
-Wikiquote
-Wikiversity
-Wikidata item
-Appearance
-move to sidebar
-hide
-From Wikipedia, the free encyclopedia
-General-purpose programming language
-Python
-Paradigm
-Multi-paradigm
-:
-object-oriented
-,
-[
-1
-]
-procedural
-(
-imperative
-),
-functional
-,
-structured
-,
-reflective
-Designed by
-Guido van Rossum
-Developer
-Python Software Foundation
-First appeared
-20 February 1991
-; 33 years ago
-(
-1991-02-20
-)
-[
-2
-]
-Stable release
-3.13.2
-   / 4 February 2025
-; 10 days ago
-(
-4 February 2025
-)
-Typing discipline
-duck
-,
-dynamic
-,
-strong
-;
-[
-3
-]
-optional type annotations
-(since 3.5, but those hints are ignored, except with unofficial tools)
-[
-4
-]
-OS
-Tier 1
-: 64-bit
-Linux
-,
-macOS
-; 64- and 32-bit
-Windows
-10+
-[
-5
-]
-Tier 2
-: E.g. 32-bit
-WebAssembly
-(WASI)
-Tier 3
-: 64-bit
-Android
-,
-[
-6
-]
-iOS
-,
-FreeBSD
-, and (32-bit)
-Raspberry Pi OS
-Unofficial (or has been known to work): Other
-Unix-like
-/
-BSD
-variants) and a few other platforms
-[
-7
-]
-[
-8
-]
-[
-9
-]
-License
-Python Software Foundation License
-Filename extensions
-.py, .pyw, .pyz,
-[
-10
-]
-.pyi, .pyc, .pyd
-Website
-python.org
-Major
-implementations
-CPython
-,
-PyPy
-,
-Stackless Python
-,
-MicroPython
-,
-CircuitPython
-,
-IronPython
-,
-Jython
-Dialects
-Cython
-,
-RPython
-,
-Starlark
-[
-11
-]
-Influenced by
-ABC
-,
-[
-12
-]
-Ada
-,
-[
-13
-]
-ALGOL 68
-,
-[
-14
-]
-APL
-,
-[
-15
-]
-C
-,
-[
-16
-]
-C++
-,
-[
-17
-]
-CLU
-,
-[
-18
-]
-Dylan
-,
-[
-19
-]
-Haskell
-,
-[
-20
-]
-[
-15
-]
-Icon
-,
-[
-21
-]
-Lisp
-,
-[
-22
-]
-Modula-3
-,
-[
-14
-]
-[
-17
-]
-Perl
-,
-[
-23
-]
-Standard ML
-[
-15
-]
-Influenced
-Apache Groovy
-,
-Boo
-,
-Cobra
-,
-CoffeeScript
-,
-[
-24
-]
-D
-,
-F#
-,
-GDScript
-,
-Go
-,
-JavaScript
-,
-[
-25
-]
-[
-26
-]
-Julia
-,
-[
-27
-]
-Mojo
-,
-[
-28
-]
-Nim
-,
-Ring
-,
-[
-29
-]
-Ruby
-,
-[
-30
-]
-Swift
-,
-[
-31
-]
-V
-[
-32
-]
-Python Programming
-at Wikibooks
-Python
-is a
-high-level
-,
-general-purpose programming language
-. Its design philosophy emphasizes
-code readability
-with the use of
-significant indentation
-.
-[
-33
-]
-Python is
-dynamically type-checked
-and
-garbage-collected
-. It supports multiple
-programming paradigms
-, including
-structured
-(particularly
-procedural
-),
-object-oriented
-and
-functional programming
-. It is often described as a "batteries included" language due to its comprehensive
-standard library
-.
-[
-34
-]
-[
-35
-]
-Guido van Rossum
-began working on Python in the late 1980s as a successor to the
-ABC
-programming language and first released it in 1991 as Python 0.9.0.
-[
-36
-]
-Python 2.0 was released in 2000. Python 3.0, released in 2008, was a major revision not completely
-backward-compatible
-with earlier versions. Python 2.7.18, released in 2020, was the last release of Python 2.
-[
-37
-]
-Python consistently ranks as one of the most popular programming languages, and has gained widespread use in the
-machine learning
-community.
-[
-38
-]
-[
-39
-]
-[
-40
-]
-[
-41
-]
-History
-[
-edit
-]
-Main article:
-History of Python
-The designer of Python,
-Guido van Rossum
-, at PyCon US 2024
-Python was conceived in the late 1980s
-[
-42
-]
-by
-Guido van Rossum
-at
-Centrum Wiskunde & Informatica
-(CWI) in the
-Netherlands
-as a successor to the
-ABC
-programming language, which was inspired by
-SETL
-,
-[
-43
-]
-capable of
-exception handling
-and interfacing with the
-Amoeba
-operating system.
-[
-12
-]
-Its implementation began in December 1989.
-[
-44
-]
-Van Rossum shouldered sole responsibility for the project, as the lead developer, until 12 July 2018, when he announced his "permanent vacation" from his responsibilities as Python's "
-benevolent dictator for life
-" (BDFL), a title the Python community bestowed upon him to reflect his long-term commitment as the project's chief decision-maker
-[
-45
-]
-(he has since come out of retirement and is self-titled "BDFL-emeritus"). In January 2019, active Python core developers elected a five-member Steering Council to lead the project.
-[
-46
-]
-[
-47
-]
-The name Python is said to come from the British comedy series
-Monty Python's Flying Circus
-.
-[
-48
-]
-Python 2.0 was released on 16 October 2000, with many major new features such as
-list comprehensions
-,
-cycle-detecting
-garbage collection,
-reference counting
-, and
-Unicode
-support.
-[
-49
-]
-Python 2.7's
-end-of-life
-was initially set for 2015, then postponed to 2020 out of concern that a large body of existing code could not easily be forward-ported to Python 3.
-[
-50
-]
-[
-51
-]
-No further security patches or other improvements will be released for it.
-[
-52
-]
-[
-53
-]
-While Python 2.7 and older versions are officially unsupported, a different unofficial Python implementation,
-PyPy
-, continues to support Python 2, i.e. "2.7.18+" (plus 3.10), with the plus meaning (at least some) "
-backported
-security updates".
-[
-54
-]
-Python 3.0 was released on 3 December 2008, with some new semantics and changed syntax. At least every Python release since (now unsupported) 3.5 has added some syntax to the language, and a few later releases have dropped outdated modules, or changed semantics, at least in a minor way.
-Since 7 October 2024
-[update]
-, Python 3.13 is the latest stable release, and it and, for few more months, 3.12 are the only releases with active support including for bug fixes (as opposed to just for security) and Python 3.9,
-[
-55
-]
-is the oldest supported version of Python (albeit in the 'security support' phase), due to Python 3.8 reaching
-end-of-life
-.
-[
-56
-]
-[
-57
-]
-Starting with 3.13, it and later versions have 2 years of full support (up from one and a half), followed by 3 years of security support (for same total support as before).
-Security updates were expedited in 2021 (and again twice in 2022, and more fixed in 2023 and in September 2024 for Python 3.12.6 down to 3.8.20), since all Python versions were insecure (including 2.7
-[
-58
-]
-) because of security issues leading to possible
-remote code execution
-[
-59
-]
-and
-web-cache poisoning
-.
-[
-60
-]
-Python 3.10 added the
-|
-union type operator
-[
-61
-]
-and the
-match
-and
-case
-keywords (for structural
-pattern matching
-statements). 3.11 expanded
-exception handling
-functionality. Python 3.12 added the new keyword
-type
-. Notable changes in 3.11 from 3.10 include increased program execution speed and improved error reporting.
-[
-62
-]
-Python 3.11 claims to be between 10 and 60% faster than Python 3.10, and Python 3.12 adds another 5% on top of that. It also has improved error messages (again improved in 3.14), and many other changes.
-Python 3.13 introduces more syntax for types, a new and improved interactive interpreter (
-REPL
-), featuring multi-line editing and color support; an incremental garbage collector (producing shorter pauses for collection in programs with a lot of objects, and addition to the improved speed in 3.11 and 3.12),  and an
-experimental
-just-in-time (JIT) compiler
-(such features, can/needs to be enabled specifically for the increase in speed),
-[
-63
-]
-and an
-experimental
-free-threaded build mode, which disables the
-global interpreter lock
-(GIL), allowing threads to run more concurrently, that latter feature enabled with
-python3.13t
-or
-python3.13t.exe
-.
-Python 3.13 introduces some change in behavior, i.e. new "well-defined semantics", fixing bugs (plus many removals of deprecated classes, functions and methods, and removed some of the C API and outdated modules): "The  [old] implementation of
-locals()
-and
-frame.f_locals
-is slow, inconsistent and buggy [and it] has many corner cases and oddities. Code that works around those may need to be changed. Code that uses
-locals()
-for simple templating, or print debugging, will continue to work corr
-
-Done!

octotools/tools/url_text_extractor/tool.py

@@ -1,105 +0,0 @@
-import os
-import requests
-from bs4 import BeautifulSoup
-
-from octotools.tools.base import BaseTool
-
-class URL_Text_Extractor_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="URL_Text_Extractor_Tool",
-            tool_description="A tool that extracts all text from a given URL.",
-            tool_version="1.0.0",
-            input_types={
-                "url": "str - The URL from which to extract text.",
-            },
-            output_type="dict - A dictionary containing the extracted text and any error messages.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(url="https://example.com")',
-                    "description": "Extract all text from the example.com website."
-                },
-                {
-                    "command": 'execution = tool.execute(url="https://en.wikipedia.org/wiki/Python_(programming_language)")',
-                    "description": "Extract all text from the Wikipedia page about Python programming language."
-                },
-            ],
-        )
-
-    def extract_text_from_url(self, url):
-        """
-        Extracts all text from the given URL.
-
-        Parameters:
-            url (str): The URL from which to extract text.
-
-        Returns:
-            str: The extracted text.
-        """
-        url = url.replace("arxiv.org/pdf", "arxiv.org/abs")
-
-        try:
-            response = requests.get(url)
-            response.raise_for_status()
-            soup = BeautifulSoup(response.content, 'html.parser')
-            text = soup.get_text(separator='\n', strip=True)
-            text = text[:10000] # Limit the text to 10000 characters
-            return text
-        except requests.RequestException as e:
-            return f"Error fetching URL: {str(e)}"
-        except Exception as e:
-            return f"Error extracting text: {str(e)}"
-
-    def execute(self, url):
-        extracted_text = self.extract_text_from_url(url)
-        return {
-            "url": url,
-            "extracted_text": extracted_text
-        }
-    
-    def get_metadata(self):
-        """
-        Returns the metadata for the URL_Text_Extractor_Tool.
-
-        Returns:
-            dict: A dictionary containing the tool's metadata.
-        """
-        metadata = super().get_metadata()
-        return metadata
-
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-
-    cd octotools/tools/url_text_extractor
-    python tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the URL_Text_Extractor_Tool
-    tool = URL_Text_Extractor_Tool()
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Sample URL for extracting text
-    url = "https://en.wikipedia.org/wiki/Python_(programming_language)"
-
-    import json
-
-    # Execute the tool with the sample URL
-    try:
-        execution = tool.execute(url=url)
-        print("Execution Result:")
-        print(json.dumps(execution, indent=4))
-        for key, value in execution.items():
-            print(f"{key}:\n{value}\n")
-    except ValueError as e:
-        print(f"Execution failed: {e}")
-
-    print("Done!")

octotools/tools/wikipedia_knowledge_searcher/test.log

@@ -1,24 +0,0 @@
-{'tool_name': 'Wikipedia_Knowledge_Searcher_Tool', 'tool_description': 'A tool that searches Wikipedia and returns web text based on a given query.', 'tool_version': '1.0.0', 'input_types': {'query': 'str - The search query for Wikipedia.'}, 'output_type': 'dict - A dictionary containing the search results, extracted text, and any error messages.', 'demo_commands': [{'command': 'execution = tool.execute(query="Python programming language")', 'description': 'Search Wikipedia for information about Python programming language.'}, {'command': 'execution = tool.execute(query="Artificial Intelligence")', 'description': 'Search Wikipedia for information about Artificial Intelligence'}, {'command': 'execution = tool.execute(query="Theory of Relativity")', 'description': 'Search Wikipedia for the full article about the Theory of Relativity.'}], 'require_llm_engine': False}
-Execution Result:
-{
-    "output": "Search results for 'kidney':\n1. Kidney\n2. Kidney failure\n3. Nephrology\n4. Kidney disease\n5. Kidney bean\n6. Kidney (disambiguation)\n7. Kidney dialysis\n8. Kidney transplantation\n9. Kidney stone disease\n10. Kidney cancer\n\nExtracted text:\nIn humans, the kidneys are two reddish-brown bean-shaped blood-filtering organs that are a multilobar, multipapillary form of mammalian kidneys, usually without signs of external lobulation. They are located on the left and right in the retroperitoneal space, and in adult humans are about 12 centimetres (4+1\u20442 inches) in length. They receive blood from the paired renal arteries; blood exits into the paired renal veins. Each kidney is attached to a ureter, a tube that carries excreted urine to the bladder.\nThe kidney participates in the control of the volume of various body fluids, fluid osmolality, acid-base balance, various electrolyte concentrations, and removal of toxins. Filtration occurs in the glomerulus: one-fifth of the blood volume that enters the kidneys is filtered. Examples of substances reabsorbed are solute-free water, sodium, bicarbonate, glucose, and amino acids. Examples of substances secreted are hydrogen, ammonium, potassium and uric acid. The nephron is the structural and functional unit of the kidney. Each adult human kidney contains around 1 million nephrons, while a mouse kidney contains only about 12,500 nephrons. The kidneys also carry out functions independent of the nephrons. For example, they convert a precursor of vitamin D to its active form, calcitriol; and synthesize the hormones erythropoietin and renin.\nChronic kidney disease (CKD) has been recognized as a leading public health problem worldwide. The global estimated prevalence of CKD is 13.4%, and patients with kidney failure needing renal replacement therapy are estimated between 5 and 7 million. Procedures used in the management of kidney disease include chemical and microscopic examination of the urine (urinalysis), measurement of kidney function by calculating the estimated glomerular filtration rate (eGFR) using the serum creatinine; and kidney biopsy and CT scan to evaluate for abnormal anatomy. Dialysis and kidney transplantation are used to treat kidney failure; one (or bot"
-}
-output:
-Search results for 'kidney':
-1. Kidney
-2. Kidney failure
-3. Nephrology
-4. Kidney disease
-5. Kidney bean
-6. Kidney (disambiguation)
-7. Kidney dialysis
-8. Kidney transplantation
-9. Kidney stone disease
-10. Kidney cancer
-
-Extracted text:
-In humans, the kidneys are two reddish-brown bean-shaped blood-filtering organs that are a multilobar, multipapillary form of mammalian kidneys, usually without signs of external lobulation. They are located on the left and right in the retroperitoneal space, and in adult humans are about 12 centimetres (4+1⁄2 inches) in length. They receive blood from the paired renal arteries; blood exits into the paired renal veins. Each kidney is attached to a ureter, a tube that carries excreted urine to the bladder.
-The kidney participates in the control of the volume of various body fluids, fluid osmolality, acid-base balance, various electrolyte concentrations, and removal of toxins. Filtration occurs in the glomerulus: one-fifth of the blood volume that enters the kidneys is filtered. Examples of substances reabsorbed are solute-free water, sodium, bicarbonate, glucose, and amino acids. Examples of substances secreted are hydrogen, ammonium, potassium and uric acid. The nephron is the structural and functional unit of the kidney. Each adult human kidney contains around 1 million nephrons, while a mouse kidney contains only about 12,500 nephrons. The kidneys also carry out functions independent of the nephrons. For example, they convert a precursor of vitamin D to its active form, calcitriol; and synthesize the hormones erythropoietin and renin.
-Chronic kidney disease (CKD) has been recognized as a leading public health problem worldwide. The global estimated prevalence of CKD is 13.4%, and patients with kidney failure needing renal replacement therapy are estimated between 5 and 7 million. Procedures used in the management of kidney disease include chemical and microscopic examination of the urine (urinalysis), measurement of kidney function by calculating the estimated glomerular filtration rate (eGFR) using the serum creatinine; and kidney biopsy and CT scan to evaluate for abnormal anatomy. Dialysis and kidney transplantation are used to treat kidney failure; one (or bot
-
-Done!

octotools/tools/wikipedia_knowledge_searcher/tool.py

@@ -1,130 +0,0 @@
-import os
-import wikipedia
-
-from octotools.tools.base import BaseTool
-
-class Wikipedia_Knowledge_Searcher_Tool(BaseTool):
-    def __init__(self):
-        super().__init__(
-            tool_name="Wikipedia_Knowledge_Searcher_Tool",
-            tool_description="A tool that searches Wikipedia and returns web text based on a given query.",
-            tool_version="1.0.0",
-            input_types={
-                "query": "str - The search query for Wikipedia.",            },
-            output_type="dict - A dictionary containing the search results, extracted text, and any error messages.",
-            demo_commands=[
-                {
-                    "command": 'execution = tool.execute(query="Python programming language")',
-                    "description": "Search Wikipedia for information about Python programming language."
-                },
-                {
-                    "command": 'execution = tool.execute(query="Artificial Intelligence")',
-                    "description": "Search Wikipedia for information about Artificial Intelligence"
-                },
-                {
-                    "command": 'execution = tool.execute(query="Theory of Relativity")',
-                    "description": "Search Wikipedia for the full article about the Theory of Relativity."
-                },
-            ],
-        )
-
-    def search_wikipedia(self, query, max_length=2000):
-        """
-        Searches Wikipedia based on the given query and returns the text.
-
-        Parameters:
-            query (str): The search query for Wikipedia.
-            max_length (int): The maximum length of the returned text. Use -1 for full text.
-
-        Returns:
-            tuple: (search_results, page_text)
-        """
-        try:
-            search_results = wikipedia.search(query)
-            if not search_results:
-                return [], "No results found for the given query."
-
-            page = wikipedia.page(search_results[0])
-            text = page.content
-
-            if max_length != -1:
-                text = text[:max_length]
-
-            return search_results, text
-        except wikipedia.exceptions.DisambiguationError as e:
-            return e.options, f"DisambiguationError: {str(e)}"
-        except wikipedia.exceptions.PageError:
-            return [], f"PageError: No Wikipedia page found for '{query}'."
-        except Exception as e:
-            return [], f"Error searching Wikipedia: {str(e)}"
-
-    def execute(self, query, max_length=2000):
-        """
-        Searches Wikipedia based on the provided query and returns the results.
-
-        Parameters:
-            query (str): The search query for Wikipedia.
-            max_length (int): The maximum length of the returned text. Use -1 for full text.
-
-        Returns:
-            dict: A dictionary containing the search results, extracted text, and formatted output.
-        """
-        search_results, text = self.search_wikipedia(query, max_length)
-        
-        formatted_output = f"Search results for '{query}':\n"
-        formatted_output += "\n".join(f"{i}. {result}" for i, result in enumerate(search_results, 1))
-        formatted_output += f"\n\nExtracted text:\n{text}"
-
-        return {
-            # "search_results": search_results,
-            # "extracted_text": text,
-            "output": formatted_output
-        }
-
-    def get_metadata(self):
-        """
-        Returns the metadata for the Wikipedia_Knowledge_Searcher_Tool.
-
-        Returns:
-            dict: A dictionary containing the tool's metadata.
-        """
-        metadata = super().get_metadata()
-        return metadata
-
-
-if __name__ == "__main__":
-    # Test command:
-    """
-    Run the following commands in the terminal to test the script:
-
-    cd octotools/tools/wikipedia_knowledge_searcher
-    python tool.py
-    """
-
-    # Get the directory of the current script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # Example usage of the Wikipedia_Knowledge_Searcher_Tool
-    tool = Wikipedia_Knowledge_Searcher_Tool()
-
-    # Get tool metadata
-    metadata = tool.get_metadata()
-    print(metadata)
-
-    # Sample query for searching Wikipedia
-    # query = "Python programming language"
-    query = "kidney"
-
-    import json
-
-    # Execute the tool with the sample query
-    try:
-        execution = tool.execute(query=query)
-        print("Execution Result:")
-        print(json.dumps(execution, indent=4))
-        for key, value in execution.items():
-            print(f"{key}:\n{value}\n")
-    except ValueError as e:
-        print(f"Execution failed: {e}")
-
-    print("Done!")