tooluniverse 0.1.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

tooluniverse/remote/uspto_downloader/uspto_downloader_tool.py

@@ -0,0 +1,120 @@
+import requests
+import fitz
+import easyocr
+from io import BytesIO
+from docx import Document
+from PIL import Image
+from .uspto_tool import USPTOOpenDataPortalTool
+from .tool_registry import register_tool
+
+
+@register_tool("USPTOPatentDocumentDownloader")
+class USPTOPatentDocumentDownloader(USPTOOpenDataPortalTool):
+    """
+    Fetch and download the abstract (ABST), claims (CLM), and full application text (APP.TEXT)
+    PDFs for a given patent application number, following the one-time redirect flow.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config=tool_config)
+
+    def run(self, arguments):
+        def ocr_pdf_bytes(pdf_bytes, dpi=300):
+            print("Running OCR on PDF bytes...")
+            doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+            pages_text = []
+
+            # Initialize EasyOCR reader once
+            reader = easyocr.Reader(["en"], gpu=True)
+
+            for page in doc:
+                # render the page to a PIL image at high resolution
+                pix = page.get_pixmap(dpi=dpi)
+                img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+                img_bytes = BytesIO()
+                img.save(img_bytes, format="PNG")
+                img_bytes.seek(0)
+                results = reader.readtext(img_bytes.getvalue(), detail=0)
+                text = "\n".join(results)
+                pages_text.append(text.strip())
+
+            doc.close()
+            return "\n\n".join(pages_text)
+
+        metadata = super().run(arguments)
+        if isinstance(metadata, dict) and metadata.get("error"):
+            return metadata
+
+        desired = self.tool_config.get("document")
+
+        docs = metadata.get("documentBag", [])
+        if not docs:
+            return {"error": "No documents found."}
+
+        result = None
+        all_doc_codes = set()
+        for doc in docs:
+            code = doc.get("documentCode")
+            all_doc_codes.add(code)
+            if code != desired:
+                continue
+
+            plain_text = ""
+            pdf_opt = None
+            word_opt = None
+            for opt in doc.get("downloadOptionBag", []):
+                m = opt.get("mimeTypeIdentifier", "").upper()
+                if m == "PDF" and not pdf_opt:
+                    pdf_opt = opt
+                elif m == "MS_WORD" and not word_opt:
+                    word_opt = opt
+
+            if word_opt:
+                url = word_opt["downloadUrl"]
+                resp = requests.get(url, headers=self.headers, timeout=30)
+                resp.raise_for_status()
+                buf = BytesIO(resp.content)
+                docx = Document(buf)
+                plain_text = "\n\n".join(
+                    p.text for p in docx.paragraphs if p.text.strip()
+                )
+
+            if not plain_text and pdf_opt:
+                url = pdf_opt["downloadUrl"]
+                resp = requests.get(url, headers=self.headers, timeout=30)
+                resp.raise_for_status()
+                pdf_bytes = resp.content
+                pdf_doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+                for page in pdf_doc:
+                    plain_text += page.get_text().strip()
+                pdf_doc.close()
+
+                if plain_text == "":
+                    # If no text was extracted, try to extract text from images
+                    plain_text = ocr_pdf_bytes(pdf_bytes)
+
+            if plain_text:
+                # if plain text is longer than current result, it is probably a better text extraction
+                if result is None or len(plain_text) > len(result):
+                    result = plain_text
+
+        if result is None:
+            return {
+                "error": f"Could not parse document with code {desired}. The documents available for this patent are: {', '.join(all_doc_codes)}."
+            }
+        else:
+            # Return the plain text extracted from the PDF
+            return {"result": result}
+
+
+# if __name__ == "__main__":
+#     # Example usage
+#     tool_config = {
+#         "name": "uspto_patent_document_downloader",
+#         "description": "Download patent documents and extract text.",
+#         "document": "ABST",  # Specify the document type to download
+#     }
+#     downloader = USPTOPatentDocumentDownloader(tool_config)
+#     arguments = {"applicationNumberText": "19053071"}  # Example application number
+#     result = downloader.run(arguments)
+#     print(result)

tooluniverse/remote_tool.py

@@ -0,0 +1,99 @@
+"""
+Remote Tool Implementation
+
+This module provides a RemoteTool class that represents external MCP/SMCP tools
+that are available for listing but cannot be executed locally. These tools are
+stored as configuration records only.
+"""
+
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("RemoteTool")
+class RemoteTool(BaseTool):
+    """
+    A placeholder tool class for external MCP/SMCP tools.
+
+    RemoteTool represents tools that are hosted on external MCP/SMCP servers
+    and are only available for discovery and listing purposes. These tools
+    cannot be executed locally through ToolUniverse but their configurations
+    are preserved for reference.
+
+    Attributes:
+        tool_config (dict): The tool configuration dictionary
+        remote_info (dict): Information about the remote server and tool
+    """
+
+    def __init__(self, tool_config=None):
+        """
+        Initialize the RemoteTool.
+
+        Args:
+            tool_config (dict, optional): Tool configuration dictionary
+        """
+        super().__init__(tool_config)
+        self.remote_info = tool_config.get("remote_info", {}) if tool_config else {}
+
+    def run(self, arguments=None):
+        """
+        Placeholder run method for remote tools.
+
+        Remote tools cannot be executed locally. This method always returns
+        an error message indicating that the tool is not available for local execution.
+
+        Args:
+            arguments (dict, optional): Tool arguments (ignored)
+
+        Returns:
+            dict: Error message indicating the tool is not available locally
+        """
+        server_type = self.remote_info.get("server_type", "Unknown")
+        original_type = self.remote_info.get("original_type", "Unknown")
+
+        return {
+            "error": "Remote tool not available for local execution",
+            "tool_name": (
+                self.tool_config.get("name", "Unknown")
+                if self.tool_config
+                else "Unknown"
+            ),
+            "tool_type": "RemoteTool",
+            "original_type": original_type,
+            "server_type": server_type,
+            "message": "This tool is hosted on an external MCP/SMCP server and cannot be executed locally. Please use the external server directly.",
+            "remote_info": self.remote_info,
+        }
+
+    def get_remote_info(self):
+        """
+        Get information about the remote server hosting this tool.
+
+        Returns:
+            dict: Remote server information including server type, URL, and original tool type
+        """
+        return self.remote_info.copy()
+
+    def is_available_locally(self):
+        """
+        Check if this tool is available for local execution.
+
+        Returns:
+            bool: Always False for RemoteTool instances
+        """
+        return False
+
+    def get_server_info(self):
+        """
+        Get server connection information for this remote tool.
+
+        Returns:
+            dict: Server connection details
+        """
+        return {
+            "server_type": self.remote_info.get("server_type"),
+            "server_url": self.remote_info.get("server_url"),
+            "transport": self.remote_info.get("transport"),
+            "mcp_tool_name": self.remote_info.get("mcp_tool_name"),
+            "source_directory": self.remote_info.get("source_directory"),
+        }

tooluniverse/restful_tool.py

@@ -1,21 +1,21 @@
 from .graphql_tool import GraphQLTool
 import requests
 import copy
-import json
+from .tool_registry import register_tool
+
 
 def execute_RESTful_query(endpoint_url, variables=None):
-    response = requests.get(
-        endpoint_url, params = variables)
+    response = requests.get(endpoint_url, params=variables)
     try:
         result = response.json()
 
         # Check if the response contains errors
-        if 'error' in result:
-            print("Invalid Query: ", result['error'])
+        if "error" in result:
+            print("Invalid Query: ", result["error"])
             return False
         else:
             return result
-    except requests.exceptions.JSONDecodeError as e:
+    except requests.exceptions.JSONDecodeError:
         print("JSONDecodeError: Could not decode the response as JSON")
         return False
     except requests.exceptions.HTTPError as e:
@@ -23,19 +23,27 @@ def execute_RESTful_query(endpoint_url, variables=None):
     except Exception as e:
         print(f"An error occurred: {e}")
 
+
+@register_tool("RESTfulTool")
 class RESTfulTool(GraphQLTool):
     def __init__(self, tool_config, endpoint_url):
         super().__init__(tool_config, endpoint_url)
 
     def run(self, arguments):
         arguments = copy.deepcopy(arguments)
-        return execute_RESTful_query(endpoint_url=self.endpoint_url, variables=arguments)
+        return execute_RESTful_query(
+            endpoint_url=self.endpoint_url, variables=arguments
+        )
+
 
+@register_tool("Monarch")
 class MonarchTool(RESTfulTool):
     def __init__(self, tool_config):
-        endpoint_url = 'https://api.monarchinitiative.org/v3/api' + tool_config['tool_url']
+        endpoint_url = (
+            "https://api.monarchinitiative.org/v3/api" + tool_config["tool_url"]
+        )
         super().__init__(tool_config, endpoint_url)
-    
+
     def run(self, arguments):
         arguments = copy.deepcopy(arguments)
         query_schema_runtime = copy.deepcopy(self.query_schema)
@@ -43,53 +51,68 @@ class MonarchTool(RESTfulTool):
             if key in arguments:
                 query_schema_runtime[key] = arguments[key]
         if "url_key" in query_schema_runtime:
-            url_key_name = query_schema_runtime['url_key']
-            formatted_endpoint_url = self.endpoint_url.format(url_key = query_schema_runtime[url_key_name])
-            del query_schema_runtime['url_key']
+            url_key_name = query_schema_runtime["url_key"]
+            formatted_endpoint_url = self.endpoint_url.format(
+                url_key=query_schema_runtime[url_key_name]
+            )
+            del query_schema_runtime["url_key"]
         else:
             formatted_endpoint_url = self.endpoint_url
         if isinstance(query_schema_runtime, dict):
             print(query_schema_runtime)
-            if 'query' in query_schema_runtime:
-                query_schema_runtime['q'] = query_schema_runtime['query'] # match with the api
-        response = execute_RESTful_query(endpoint_url=formatted_endpoint_url, variables=query_schema_runtime)
-        if 'facet_fields' in response:
-            del response['facet_fields']
+            if "query" in query_schema_runtime:
+                query_schema_runtime["q"] = query_schema_runtime[
+                    "query"
+                ]  # match with the api
+        response = execute_RESTful_query(
+            endpoint_url=formatted_endpoint_url, variables=query_schema_runtime
+        )
+        if "facet_fields" in response:
+            del response["facet_fields"]
+
         def remove_empty_values(obj):
             if isinstance(obj, dict):
-                return {k: remove_empty_values(v) for k, v in obj.items()
-                        if v not in [0, [], None]}
+                return {
+                    k: remove_empty_values(v)
+                    for k, v in obj.items()
+                    if v not in [0, [], None]
+                }
             elif isinstance(obj, list):
                 return [remove_empty_values(v) for v in obj if v not in [0, [], None]]
             else:
                 return obj
+
         response = remove_empty_values(response)
         return response
 
+
+@register_tool("MonarchDiseasesForMultiplePheno")
 class MonarchDiseasesForMultiplePhenoTool(MonarchTool):
     def __init__(self, tool_config):
         super().__init__(tool_config)
-    
+
     def run(self, arguments):
         arguments = copy.deepcopy(arguments)
         query_schema_runtime = copy.deepcopy(self.query_schema)
         for key in query_schema_runtime:
-            if (key!="HPO_ID_list") and (key in arguments):
+            if (key != "HPO_ID_list") and (key in arguments):
                 query_schema_runtime[key] = arguments[key]
         all_diseases = []
-        for HPOID in arguments['HPO_ID_list']:
+        for HPOID in arguments["HPO_ID_list"]:
             each_query_schema_runtime = copy.deepcopy(query_schema_runtime)
-            each_query_schema_runtime['object'] = HPOID
-            each_query_schema_runtime['limit'] = 500
-            each_output = execute_RESTful_query(endpoint_url=self.endpoint_url, variables=each_query_schema_runtime)
-            each_output = each_output['items']
-            each_output_names = [disease['subject_label'] for disease in each_output]
+            each_query_schema_runtime["object"] = HPOID
+            each_query_schema_runtime["limit"] = 500
+            each_output = execute_RESTful_query(
+                endpoint_url=self.endpoint_url, variables=each_query_schema_runtime
+            )
+            each_output = each_output["items"]
+            each_output_names = [disease["subject_label"] for disease in each_output]
             all_diseases.append(each_output_names)
-        
+
         intersection = set(all_diseases[0])
         for element in all_diseases[1:]:
             intersection &= set(element)
         intersection = list(intersection)
-        if query_schema_runtime['limit'] < len(intersection):
-            intersection = intersection[:query_schema_runtime['limit']]
+        if query_schema_runtime["limit"] < len(intersection):
+            intersection = intersection[: query_schema_runtime["limit"]]
         return intersection