tooluniverse 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

tooluniverse/biorxiv_tool.py

@@ -6,7 +6,7 @@ from .tool_registry import register_tool
 @register_tool("BioRxivTool")
 class BioRxivTool(BaseTool):
     """
-    Search bioRxiv preprints using the public bioRxiv API.
+    Search bioRxiv preprints using bioRxiv's API (same interface as medRxiv).
 
     Arguments:
         query (str): Search term
@@ -16,7 +16,7 @@ class BioRxivTool(BaseTool):
     def __init__(
         self,
         tool_config,
-        base_url="https://api.medrxiv.org/details",
+        base_url="https://api.biorxiv.org/details",
     ):
         super().__init__(tool_config)
         self.base_url = base_url
@@ -30,17 +30,19 @@ class BioRxivTool(BaseTool):
         return self._search(query, max_results)
 
     def _search(self, query, max_results):
-        # Use date range search for recent preprints
+        # Use date range search for preprints
         # Format: /biorxiv/{start_date}/{end_date}/{cursor}/json
         from datetime import datetime, timedelta
 
-        # Search last 30 days
+        # Search last 365 days to get more comprehensive results
         end_date = datetime.now()
-        start_date = end_date - timedelta(days=30)
+        start_date = end_date - timedelta(days=365)
 
-        url = (f"{self.base_url}/biorxiv/"
-               f"{start_date.strftime('%Y-%m-%d')}/"
-               f"{end_date.strftime('%Y-%m-%d')}/0/json")
+        url = (
+            f"{self.base_url}/biorxiv/"
+            f"{start_date.strftime('%Y-%m-%d')}/"
+            f"{end_date.strftime('%Y-%m-%d')}/0/json"
+        )
 
         try:
             resp = requests.get(url, timeout=20)
@@ -78,19 +80,36 @@ class BioRxivTool(BaseTool):
             doi = item.get("doi")
             url = f"https://www.biorxiv.org/content/{doi}" if doi else None
 
-            # Filter by query if provided
-            if query and query.lower() not in (title or "").lower():
-                continue
+            # Filter by query if provided - search in both title and abstract
+            if query:
+                title_match = query.lower() in (title or "").lower()
+                abstract_match = (
+                    query.lower() in (item.get("abstract", "") or "").lower()
+                )
+                if not (title_match or abstract_match):
+                    continue
 
             results.append(
                 {
-                    "title": title,
-                    "authors": authors,
+                    "title": title or "Title not available",
+                    "authors": (
+                        authors if authors else "Author information not available"
+                    ),
                     "year": year,
-                    "doi": doi,
-                    "url": url,
-                    "abstract": item.get("abstract", ""),
+                    "doi": doi or "DOI not available",
+                    "url": url or "URL not available",
+                    "abstract": item.get("abstract", "Abstract not available"),
                     "source": "bioRxiv",
+                    "data_quality": {
+                        "has_abstract": bool(
+                            item.get("abstract")
+                            and item.get("abstract") != "Abstract not available"
+                        ),
+                        "has_authors": bool(authors),
+                        "has_year": bool(year),
+                        "has_doi": bool(doi),
+                        "has_url": bool(url),
+                    },
                 }
             )
 

tooluniverse/build_optimizer.py

@@ -0,0 +1,87 @@
+"""Build optimization utilities for ToolUniverse tools."""
+
+import json
+import hashlib
+from pathlib import Path
+from typing import Dict, Any, Set, Tuple
+
+
+def calculate_tool_hash(tool_config: Dict[str, Any]) -> str:
+    """Calculate a hash for tool configuration to detect changes."""
+    # Create a normalized version of the config for hashing
+    normalized_config = {}
+    for key, value in sorted(tool_config.items()):
+        if key not in ["timestamp", "last_updated", "created_at"]:
+            normalized_config[key] = value
+
+    config_str = json.dumps(normalized_config, sort_keys=True, separators=(",", ":"))
+    return hashlib.md5(config_str.encode("utf-8")).hexdigest()
+
+
+def load_metadata(metadata_file: Path) -> Dict[str, str]:
+    """Load tool metadata from file."""
+    if not metadata_file.exists():
+        return {}
+
+    try:
+        with open(metadata_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def save_metadata(metadata: Dict[str, str], metadata_file: Path) -> None:
+    """Save tool metadata to file."""
+    metadata_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(metadata_file, "w", encoding="utf-8") as f:
+        json.dump(metadata, f, indent=2, sort_keys=True)
+
+
+def cleanup_orphaned_files(tools_dir: Path, current_tool_names: Set[str]) -> int:
+    """Remove files for tools that no longer exist."""
+    if not tools_dir.exists():
+        return 0
+
+    cleaned_count = 0
+    keep_files = {"__init__", "_shared_client", "__pycache__"}
+
+    for file_path in tools_dir.iterdir():
+        if (
+            file_path.is_file()
+            and file_path.suffix == ".py"
+            and file_path.stem not in keep_files
+            and file_path.stem not in current_tool_names
+        ):
+            print(f"🗑️  Removing orphaned tool file: {file_path.name}")
+            file_path.unlink()
+            cleaned_count += 1
+
+    return cleaned_count
+
+
+def get_changed_tools(
+    current_tools: Dict[str, Any], metadata_file: Path
+) -> Tuple[list, list, list]:
+    """Get lists of new, changed, and unchanged tools."""
+    old_metadata = load_metadata(metadata_file)
+    new_metadata = {}
+    new_tools = []
+    changed_tools = []
+    unchanged_tools = []
+
+    for tool_name, tool_config in current_tools.items():
+        current_hash = calculate_tool_hash(tool_config)
+        new_metadata[tool_name] = current_hash
+
+        old_hash = old_metadata.get(tool_name)
+        if old_hash is None:
+            new_tools.append(tool_name)
+        elif old_hash != current_hash:
+            changed_tools.append(tool_name)
+        else:
+            unchanged_tools.append(tool_name)
+
+    # Save updated metadata
+    save_metadata(new_metadata, metadata_file)
+
+    return new_tools, changed_tools, unchanged_tools

tooluniverse/cache/__init__.py

@@ -0,0 +1,3 @@
+"""Cache utilities for ToolUniverse."""
+
+from .result_cache_manager import ResultCacheManager  # noqa: F401

tooluniverse/cache/memory_cache.py

@@ -0,0 +1,99 @@
+"""
+In-memory cache utilities for ToolUniverse.
+
+Provides a lightweight, thread-safe LRU cache with optional singleflight
+deduplication for expensive misses.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import OrderedDict
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, Optional, Tuple
+
+
+class LRUCache:
+    """Thread-safe LRU cache with basic telemetry."""
+
+    def __init__(self, max_size: int = 128):
+        self.max_size = max(1, int(max_size))
+        self._data: "OrderedDict[str, Tuple[Any, float]]" = OrderedDict()
+        self._lock = threading.RLock()
+        self.hits = 0
+        self.misses = 0
+
+    def get(self, key: str) -> Optional[Any]:
+        with self._lock:
+            if key not in self._data:
+                self.misses += 1
+                return None
+
+            value, timestamp = self._data.pop(key)
+            self._data[key] = (value, timestamp)
+            self.hits += 1
+            return value
+
+    def set(self, key: str, value: Any):
+        with self._lock:
+            if key in self._data:
+                self._data.pop(key)
+            self._data[key] = (value, time.time())
+            self._evict_if_needed()
+
+    def delete(self, key: str):
+        with self._lock:
+            self._data.pop(key, None)
+
+    def clear(self):
+        with self._lock:
+            self._data.clear()
+            self.hits = 0
+            self.misses = 0
+
+    def _evict_if_needed(self):
+        while len(self._data) > self.max_size:
+            self._data.popitem(last=False)
+
+    def stats(self) -> Dict[str, Any]:
+        with self._lock:
+            return {
+                "max_size": self.max_size,
+                "current_size": len(self._data),
+                "hits": self.hits,
+                "misses": self.misses,
+            }
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._data)
+
+    def items(self) -> Iterator[Tuple[str, Any]]:
+        with self._lock:
+            for key, (value, _) in list(self._data.items()):
+                yield key, value
+
+
+class SingleFlight:
+    """Per-key lock manager to collapse duplicate cache misses."""
+
+    def __init__(self):
+        self._locks: Dict[str, threading.Lock] = {}
+        self._global = threading.Lock()
+
+    @contextmanager
+    def acquire(self, key: str):
+        with self._global:
+            lock = self._locks.get(key)
+            if lock is None:
+                lock = threading.Lock()
+                self._locks[key] = lock
+        lock.acquire()
+        try:
+            yield
+        finally:
+            lock.release()
+            with self._global:
+                if not lock.locked():
+                    self._locks.pop(key, None)

tooluniverse/cache/result_cache_manager.py

@@ -0,0 +1,235 @@
+"""
+Result cache manager that coordinates in-memory and persistent storage.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, Iterator, Optional
+
+from .memory_cache import LRUCache, SingleFlight
+from .sqlite_backend import CacheEntry, PersistentCache
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CacheRecord:
+    value: Any
+    expires_at: Optional[float]
+    namespace: str
+    version: str
+
+
+class ResultCacheManager:
+    """Facade around memory + persistent cache layers."""
+
+    def __init__(
+        self,
+        *,
+        memory_size: int = 256,
+        persistent_path: Optional[str] = None,
+        enabled: bool = True,
+        persistence_enabled: bool = True,
+        singleflight: bool = True,
+        default_ttl: Optional[int] = None,
+    ):
+        self.enabled = enabled
+        self.default_ttl = default_ttl
+
+        self.memory = LRUCache(max_size=memory_size)
+        persistence_path = persistent_path
+        if persistence_path is None:
+            cache_dir = os.environ.get("TOOLUNIVERSE_CACHE_DIR")
+            if cache_dir:
+                persistence_path = os.path.join(cache_dir, "tooluniverse_cache.sqlite")
+        self.persistent = None
+        if persistence_enabled and persistence_path:
+            try:
+                self.persistent = PersistentCache(persistence_path, enable=True)
+            except Exception as exc:
+                logger.warning("Failed to initialize persistent cache: %s", exc)
+                self.persistent = None
+
+        self.singleflight = SingleFlight() if singleflight else None
+
+    # ------------------------------------------------------------------
+    # Helper methods
+    # ------------------------------------------------------------------
+    @staticmethod
+    def compose_key(namespace: str, version: str, cache_key: str) -> str:
+        return f"{namespace}::{version}::{cache_key}"
+
+    def _now(self) -> float:
+        return time.time()
+
+    def _ttl_or_default(self, ttl: Optional[int]) -> Optional[int]:
+        return ttl if ttl is not None else self.default_ttl
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def get(self, *, namespace: str, version: str, cache_key: str) -> Optional[Any]:
+        if not self.enabled:
+            return None
+
+        composed = self.compose_key(namespace, version, cache_key)
+        record = self.memory.get(composed)
+        if record:
+            if record.expires_at and record.expires_at <= self._now():
+                self.memory.delete(composed)
+            else:
+                return record.value
+
+        entry = self._get_from_persistent(composed)
+        if entry:
+            expires_at = entry.created_at + entry.ttl if entry.ttl else None
+            self.memory.set(
+                composed,
+                CacheRecord(
+                    value=entry.value,
+                    expires_at=expires_at,
+                    namespace=namespace,
+                    version=version,
+                ),
+            )
+            return entry.value
+        return None
+
+    def set(
+        self,
+        *,
+        namespace: str,
+        version: str,
+        cache_key: str,
+        value: Any,
+        ttl: Optional[int] = None,
+    ):
+        if not self.enabled:
+            return
+
+        effective_ttl = self._ttl_or_default(ttl)
+        expires_at = self._now() + effective_ttl if effective_ttl else None
+        composed = self.compose_key(namespace, version, cache_key)
+
+        self.memory.set(
+            composed,
+            CacheRecord(
+                value=value,
+                expires_at=expires_at,
+                namespace=namespace,
+                version=version,
+            ),
+        )
+
+        if self.persistent:
+            try:
+                self.persistent.set(
+                    composed,
+                    value,
+                    namespace=namespace,
+                    version=version,
+                    ttl=effective_ttl,
+                )
+            except Exception as exc:
+                logger.warning("Persistent cache write failed: %s", exc)
+                self.persistent = None
+
+    def delete(self, *, namespace: str, version: str, cache_key: str):
+        composed = self.compose_key(namespace, version, cache_key)
+        self.memory.delete(composed)
+        if self.persistent:
+            try:
+                self.persistent.delete(composed)
+            except Exception as exc:
+                logger.warning("Persistent cache delete failed: %s", exc)
+
+    def clear(self, namespace: Optional[str] = None):
+        if namespace:
+            # Clear matching namespace in memory
+            keys_to_remove = [
+                key
+                for key, record in self.memory.items()
+                if hasattr(record, "namespace") and record.namespace == namespace
+            ]
+            for key in keys_to_remove:
+                self.memory.delete(key)
+        else:
+            self.memory.clear()
+
+        if self.persistent:
+            try:
+                self.persistent.clear(namespace=namespace)
+            except Exception as exc:
+                logger.warning("Persistent cache clear failed: %s", exc)
+
+    def stats(self) -> Dict[str, Any]:
+        return {
+            "enabled": self.enabled,
+            "memory": self.memory.stats(),
+            "persistent": (
+                self.persistent.stats() if self.persistent else {"enabled": False}
+            ),
+        }
+
+    def dump(self, namespace: Optional[str] = None) -> Iterator[Dict[str, Any]]:
+        if not self.persistent:
+            return iter([])
+        return (
+            {
+                "cache_key": entry.key,
+                "namespace": entry.namespace,
+                "version": entry.version,
+                "ttl": entry.ttl,
+                "created_at": entry.created_at,
+                "last_accessed": entry.last_accessed,
+                "hit_count": entry.hit_count,
+                "value": entry.value,
+            }
+            for entry in self._iter_persistent(namespace=namespace)
+        )
+
+    def _get_from_persistent(self, composed_key: str) -> Optional[CacheEntry]:
+        if not self.persistent:
+            return None
+        try:
+            return self.persistent.get(composed_key)
+        except Exception as exc:
+            logger.warning("Persistent cache read failed: %s", exc)
+            self.persistent = None
+            return None
+
+    def _iter_persistent(self, namespace: Optional[str]):
+        if not self.persistent:
+            return iter([])
+        try:
+            return self.persistent.iter_entries(namespace=namespace)
+        except Exception as exc:
+            logger.warning("Persistent cache iterator failed: %s", exc)
+            return iter([])
+
+    # ------------------------------------------------------------------
+    # Context manager for singleflight
+    # ------------------------------------------------------------------
+    def singleflight_guard(self, composed_key: str):
+        if self.singleflight:
+            return self.singleflight.acquire(composed_key)
+        return _DummyContext()
+
+    def close(self):
+        if self.persistent:
+            try:
+                self.persistent.close()
+            except Exception as exc:
+                logger.warning("Persistent cache close failed: %s", exc)
+
+
+class _DummyContext:
+    def __enter__(self):
+        return None
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False