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

tooluniverse/url_tool.py

@@ -0,0 +1,253 @@
+import requests
+import re
+from .base_tool import BaseTool
+from html import unescape
+from .tool_registry import register_tool
+import io
+import os
+import sys
+import subprocess
+import pdfplumber
+from playwright.sync_api import sync_playwright
+
+
+@register_tool("URLHTMLTagTool")
+class URLHTMLTagTool(BaseTool):
+    """
+    Fetches a webpage and extracts the content of a specified HTML tag.
+    Expects: {"url": "https://..."}
+    The tag to extract is specified in the tool's configuration.
+    The tag to extract is specified in the tool's configuration.
+    Optional: {"timeout": <seconds>} (default 20)
+    Returns: {"content": "<extracted content>"} or {"error": "..."}
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.tag_to_fetch = tool_config["fields"].get("tag", "title")
+        self.return_key = tool_config["fields"].get("return_key", "content")
+
+    def run(self, arguments: dict):
+        url = arguments.get("url")
+        if not url:
+            return {"error": "Parameter 'url' is required."}
+
+        # Basic validation
+        if not (url.startswith("http://") or url.startswith("https://")):
+            return {"error": "URL must start with http:// or https://"}
+
+        timeout = arguments.get("timeout", 20)
+        try:
+            resp = requests.get(url, timeout=timeout)
+        except requests.Timeout:
+            return {"error": "Request timed out."}
+        except Exception as e:
+            return {"error": f"Request failed: {e}"}
+
+        if resp.status_code != 200:
+            return {"error": f"HTTP {resp.status_code}", "detail": resp.text[:300]}
+
+        ctype = resp.headers.get("Content-Type", "").lower()
+        if "html" not in ctype:
+            # Still attempt extraction if text-like
+            if not ctype.startswith("text/"):
+                return {"error": "Response is not HTML."}
+
+        text = resp.text
+
+        # Extract <tag>...</tag>
+        m = re.search(
+            rf"<{self.tag_to_fetch}>(.*?)</{self.tag_to_fetch}>",
+            text,
+            flags=re.IGNORECASE | re.DOTALL,
+        )
+        if not m:
+            return {"error": f"No <{self.tag_to_fetch}> tag found."}
+
+        raw_content = m.group(1).strip()
+        # Collapse whitespace
+        cleaned = re.sub(r"\s+", " ", raw_content)
+        cleaned = unescape(cleaned)
+
+        return {self.return_key: cleaned}
+
+
+@register_tool("URLToPDFTextTool")
+class URLToPDFTextTool(BaseTool):
+    """
+    Loads a webpage (with JavaScript), exports it as a PDF, and extracts text.
+    Expects: {"url": "https://..."}
+    Optional: {"timeout": <seconds>} (default 30)
+    Returns: {"text": "<extracted text>"} or {"error": "..."}
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.return_key = tool_config["fields"].get("return_key", "text")
+
+    def _ensure_playwright_browsers(
+        self,
+        browsers=("chromium",),
+        with_deps: bool = False,
+        timeout_seconds: int = 600,
+    ):
+        """
+        Ensure Playwright browser binaries are installed.
+
+        Returns:
+            None on success, or an error string on failure.
+        """
+        # Allow user to skip auto-install via env var
+        if os.environ.get("PLAYWRIGHT_SKIP_BROWSER_INSTALL", "") in (
+            "1",
+            "true",
+            "True",
+        ):
+            return "PLAYWRIGHT_SKIP_BROWSER_INSTALL is set; skipping browser install."
+
+        # Detect if running inside an active asyncio event loop (Colab/Jupyter)
+        try:
+            import asyncio
+
+            loop = asyncio.get_event_loop()
+            running_async = loop.is_running()
+        except Exception:
+            running_async = False
+
+        def try_launch_one_sync():
+            try:
+                from playwright.sync_api import sync_playwright
+
+                with sync_playwright() as p:
+                    b = getattr(p, browsers[0])
+                    browser = b.launch(headless=True, timeout=10_000)
+                    browser.close()
+                return True, None
+            except Exception as e:
+                return False, str(e)
+
+        async def try_launch_one_async():
+            try:
+                from playwright.async_api import async_playwright
+
+                async with async_playwright() as p:
+                    b = getattr(p, browsers[0])
+                    browser = await b.launch(headless=True, timeout=10_000)
+                    await browser.close()
+                return True, None
+            except Exception as e:
+                return False, str(e)
+
+        if running_async:
+            # Use async Playwright API for browser launch check
+            try:
+                ok, msg = loop.run_until_complete(try_launch_one_async())
+            except Exception as e:
+                ok, msg = False, str(e)
+        else:
+            ok, msg = try_launch_one_sync()
+
+        if ok:
+            return None  # browsers are already installed
+
+        # Attempt install using the same Python executable
+        cmd = [sys.executable, "-m", "playwright", "install"] + list(browsers)
+        if with_deps:
+            cmd.append("--with-deps")
+
+        try:
+            subprocess.run(
+                cmd, check=True, capture_output=True, text=True, timeout=timeout_seconds
+            )
+        except subprocess.CalledProcessError as e:
+            stdout = e.stdout or ""
+            stderr = e.stderr or ""
+            return f"playwright install failed (exit {e.returncode}). stdout:\n{stdout}\nstderr:\n{stderr}"
+        except Exception as e:
+            return f"Failed to run playwright install: {e}"
+
+        # Try launching again after install
+        if running_async:
+            try:
+                ok2, msg2 = loop.run_until_complete(try_launch_one_async())
+            except Exception as e:
+                ok2, msg2 = False, str(e)
+        else:
+            ok2, msg2 = try_launch_one_sync()
+
+        if ok2:
+            return None
+        return f"Browsers installed but launch still fails: {msg2}"
+
+    def run(self, arguments: dict):
+        url = arguments.get("url")
+        if not url:
+            return {"error": "Parameter 'url' is required."}
+        if not (url.startswith("http://") or url.startswith("https://")):
+            return {"error": "URL must start with http:// or https://"}
+
+        timeout = arguments.get("timeout", 30)
+
+        # Ensure browsers are installed (auto-install if needed)
+        ensure_error = self._ensure_playwright_browsers(
+            browsers=("chromium",), with_deps=False
+        )
+        if ensure_error is not None:
+            return {"error": f"Playwright browser check/install failed: {ensure_error}"}
+
+        # Detect if running inside an active asyncio event loop (Colab/Jupyter)
+        try:
+            import asyncio
+
+            loop = asyncio.get_event_loop()
+            running_async = loop.is_running()
+        except Exception:
+            running_async = False
+
+        if running_async:
+            # Use async Playwright API
+            from playwright.async_api import async_playwright
+            import nest_asyncio
+
+            nest_asyncio.apply()
+
+            async def async_pdf():
+                async with async_playwright() as p:
+                    browser = await p.chromium.launch(headless=True)
+                    page = await browser.new_page()
+                    await page.goto(
+                        url, timeout=timeout * 1000, wait_until="networkidle"
+                    )
+                    pdf_bytes = await page.pdf(format="A4", print_background=True)
+                    await browser.close()
+                    return pdf_bytes
+
+            try:
+                pdf_bytes = loop.run_until_complete(async_pdf())
+            except Exception as e:
+                return {"error": f"Failed to render webpage to PDF (async): {e}"}
+        else:
+            # Use sync Playwright API
+            try:
+                with sync_playwright() as p:
+                    browser = p.chromium.launch(headless=True)
+                    page = browser.new_page()
+                    page.goto(url, timeout=timeout * 1000, wait_until="networkidle")
+                    pdf_bytes = page.pdf(format="A4", print_background=True)
+                    browser.close()
+            except Exception as e:
+                return {"error": f"Failed to render webpage to PDF (sync): {e}"}
+
+        # Step 2: Extract text from PDF
+        try:
+            text = ""
+            with pdfplumber.open(io.BytesIO(pdf_bytes)) as pdf:
+                for page in pdf.pages:
+                    page_text = page.extract_text()
+                    if page_text:
+                        text += page_text + "\n"
+            if not text.strip():
+                return {"error": "No text could be extracted from rendered PDF."}
+            return {self.return_key: text.strip()}
+        except Exception as e:
+            return {"error": f"Failed to extract text from PDF: {e}"}

tooluniverse/uspto_tool.py

@@ -0,0 +1,240 @@
+import requests
+import json
+import re
+import os
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+from dotenv import load_dotenv, find_dotenv
+
+load_dotenv(find_dotenv(usecwd=True))
+
+USPTO_API_KEY = os.environ.get("USPTO_API_KEY")
+
+
+@register_tool("USPTOOpenDataPortalTool")
+class USPTOOpenDataPortalTool(BaseTool):
+    """
+    A tool for interacting with the USPTO Open Data Portal API to search for and retrieve patent information.
+    The run method dynamically constructs API requests based on the provided tool configuration.
+    """
+
+    def __init__(
+        self,
+        tool_config,
+        api_key=USPTO_API_KEY,
+        base_url="https://api.uspto.gov/api/v1",
+    ):
+        """
+        Initializes the USPTOOpenDataPortalTool.
+
+        Args:
+            tool_config: The configuration for the specific tool being run.
+            api_key: Your USPTO Open Data Portal API key.
+            base_url: The base URL for the USPTO API.
+        """
+        super().__init__(tool_config)
+        self.base_url = base_url
+        if api_key == "YOUR_API_KEY" or not api_key:
+            raise ValueError(
+                "You must set a USPTO API key via the USPTO_API_KEY environment variable."
+            )
+        self.headers = {"X-API-KEY": api_key, "Accept": "application/json"}
+        self.session = requests.Session()
+        retry_strategy = Retry(
+            total=5,
+            status_forcelist=[429, 500, 502, 503, 504],
+            backoff_factor=5,  # first retry waits 5s, then 10s, 20s, …
+            raise_on_status=False,
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("https://", adapter)
+
+    def get_by_path(self, d, keys):
+        """Safely navigate nested dicts by a list of keys."""
+        for k in keys:
+            if d is None:
+                return None
+            if isinstance(d, dict):
+                d = d.get(k)
+            else:
+                return None
+        return d
+
+    def assign_by_path(self, d, path, value):
+        """Create nested dicts for a dot‑path and set the final key to value."""
+        keys = path.split(".")
+        for k in keys[:-1]:
+            d = d.setdefault(k, {})
+        d[keys[-1]] = value
+
+    def prune_item(self, item, return_fields):
+        out = {}
+        missing_fields = []
+
+        # 1) First, handle all the list‑of‑objects fields (the "/" ones),
+        #    grouping them by their list‑path prefix.
+        list_groups = {}
+        for field in return_fields:
+            if "/" in field:
+                list_path, prop = field.split("/", 1)
+                list_groups.setdefault(list_path, []).append(prop)
+
+        for list_path, props in list_groups.items():
+            prefix_keys = list_path.split(".")
+            raw_list = self.get_by_path(item, prefix_keys)
+            if not isinstance(raw_list, list):
+                for prop in props:
+                    missing_fields.append(f"{list_path}/{prop}")
+                continue
+
+            pruned_list = []
+            prop_found = {prop: False for prop in props}
+            for el in raw_list:
+                if not isinstance(el, dict):
+                    continue
+                pruned_el = {}
+                for prop in props:
+                    if prop in el:
+                        pruned_el[prop] = el[prop]
+                        prop_found[prop] = True
+                if pruned_el:
+                    pruned_list.append(pruned_el)
+
+            # Track missing properties
+            for prop, found in prop_found.items():
+                if not found:
+                    missing_fields.append(f"{list_path}/{prop}")
+
+            if pruned_list:
+                self.assign_by_path(out, list_path, pruned_list)
+
+        # 2) Then handle all the scalar or nested‑dict fields (the "." ones without "/").
+        for field in return_fields:
+            if "/" in field:
+                continue  # already done
+            keys = field.split(".")
+            raw_value = self.get_by_path(item, keys)
+            if raw_value is None:
+                missing_fields.append(field)
+                continue
+
+            self.assign_by_path(out, field, raw_value)
+
+        out["missing_fields"] = missing_fields
+        return out
+
+    def run(self, arguments):
+        """
+        Runs the specified tool by constructing and executing an API call based on the tool's configuration.
+
+        Args:
+            arguments: A dictionary of arguments for the tool, matching the parameters in the tool definition.
+
+        Returns:
+            The result of the API call, either as a dictionary (for JSON) or a string (for CSV).
+        """
+        endpoint = self.tool_config.get("api_endpoint")
+        if not endpoint:
+            return {"error": "API endpoint not found in tool configuration."}
+
+        path_params = re.findall(r"\{(\w+)\}", endpoint)
+        query_params = {}
+
+        # Substitute path parameters and build query string parameters
+        for key, value in arguments.items():
+            if key in path_params:
+                endpoint = endpoint.replace(f"{{{key}}}", str(value))
+            else:
+                query_params[key] = value
+
+        # Remove any None values from the query parameters
+        for k, v in query_params.items():
+            if v is None:
+                if (
+                    self.tool_config.get("parameter")
+                    .get("properties")
+                    .get(k)
+                    .get("default")
+                    is not None
+                ):
+                    query_params[k] = (
+                        self.tool_config.get("parameter")
+                        .get("properties")
+                        .get(k)
+                        .get("default")
+                    )
+                else:
+                    del query_params[k]
+
+        # default parameters if not provided
+        for k, v in self.tool_config.get("default_query_params", {}).items():
+            if k not in query_params or query_params[k] is None:
+                query_params[k] = v
+
+        # Special handling for the inputs to this tool
+        if self.tool_config.get("name") == "get_patent_overview_by_text_query":
+            if "query" in query_params:
+                query_params["q"] = query_params["query"]
+                del query_params["query"]
+            else:
+                return {"error": "Missing required parameter 'query'."}
+
+            if query_params["exact_match"]:
+                query_params["q"] = f'"{query_params["q"]}"'
+                del query_params["exact_match"]
+
+            field_mappings = {
+                "filingDate": "applicationMetaData.filingDate",
+                "grantDate": "applicationMetaData.grantDate",
+            }
+
+            for old_field, new_field in field_mappings.items():
+                if old_field in query_params.get("sort", ""):
+                    query_params["sort"] = query_params["sort"].replace(
+                        old_field, new_field
+                    )
+                if old_field in query_params.get("rangeFilters", ""):
+                    query_params["rangeFilters"] = query_params["rangeFilters"].replace(
+                        old_field, new_field
+                    )
+
+        try:
+            # The timeout for downloads can be longer
+            timeout = 120 if "download" in self.tool_config.get("name", "") else 30
+
+            response = self.session.get(
+                f"{self.base_url}/{endpoint}",
+                headers=self.headers,
+                params=query_params,
+                timeout=timeout,
+            )
+            response.raise_for_status()
+
+            # Otherwise, assume the response is JSON
+            if self.tool_config.get("return_fields", []):
+                # Filter the JSON response to only include specified fields
+                pruned_patents = []
+                result = response.json()
+                for patent in result.get("patentFileWrapperDataBag", []):
+                    pruned_patents.append(
+                        self.prune_item(patent, self.tool_config.get("return_fields"))
+                    )
+                result["patentFileWrapperDataBag"] = pruned_patents
+            else:
+                result = response.json()
+            return result
+
+        except requests.exceptions.HTTPError as http_err:
+            # Attempt to return the structured error from the API response body
+            try:
+                error_details = http_err.response.json()
+            except json.JSONDecodeError:
+                error_details = http_err.response.text
+            return {
+                "error": f"HTTP Error: {http_err.response.status_code}",
+                "details": error_details,
+            }
+        except requests.exceptions.RequestException as e:
+            return {"error": "API request failed", "details": str(e)}