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

tooluniverse/compose_tool.py

@@ -9,6 +9,7 @@ import traceback
 import os
 import importlib.util
 import re
+from datetime import datetime
 from typing import Set
 from .base_tool import BaseTool
 from .tool_registry import register_tool
@@ -204,12 +205,13 @@ class ComposeTool(BaseTool):
             print(f"Error loading composition file {self.composition_file}: {e}")
             return f"# Error loading file: {e}\nresult = {{'error': 'Failed to load composition code'}}"
 
-    def run(self, arguments):
+    def run(self, arguments, stream_callback=None):
         """
         Execute the composed tool with custom code logic.
 
         Args:
             arguments (dict): Input arguments for the composition
+            stream_callback (callable, optional): Callback function for streaming output
 
         Returns:
             Any: Result from the composition execution
@@ -268,10 +270,10 @@ class ComposeTool(BaseTool):
         try:
             if self.composition_file:
                 # Execute function from external file
-                return self._execute_from_file(arguments)
+                return self._execute_from_file(arguments, stream_callback)
             else:
                 # Execute inline code (existing behavior)
-                return self._execute_inline_code(arguments)
+                return self._execute_inline_code(arguments, stream_callback)
 
         except Exception as e:
             error_msg = f"Error in ComposeTool '{self.name}': {str(e)}"
@@ -280,12 +282,50 @@ class ComposeTool(BaseTool):
 
             return {"error": error_msg, "traceback": traceback.format_exc()}
 
-    def _execute_from_file(self, arguments):
+    def _emit_stream_chunk(self, chunk, stream_callback):
+        """
+        Emit a stream chunk if callback is provided.
+
+        Args:
+            chunk (str): The chunk to emit
+            stream_callback (callable, optional): Callback function for streaming output
+        """
+        if stream_callback and chunk:
+            try:
+                stream_callback(chunk)
+            except Exception as e:
+                print(f"Error in stream callback: {e}")
+
+    def _create_event_emitter(self, stream_callback):
+        """
+        Create an event emitter function for the compose script.
+
+        Args:
+            stream_callback (callable, optional): Callback function for streaming output
+
+        Returns:
+            callable: Event emitter function
+        """
+
+        def emit_event(event_type, data=None):
+            """Emit an event via stream callback"""
+            if stream_callback:
+                event = {
+                    "type": event_type,
+                    "timestamp": datetime.now().isoformat(),
+                    "data": data or {},
+                }
+                self._emit_stream_chunk(json.dumps(event), stream_callback)
+
+        return emit_event
+
+    def _execute_from_file(self, arguments, stream_callback=None):
         """
         Execute composition code from external file.
 
         Args:
             arguments (dict): Input arguments
+            stream_callback (callable, optional): Callback function for streaming output
 
         Returns:
             Any: Result from the composition execution
@@ -302,15 +342,40 @@ class ComposeTool(BaseTool):
         # Get the composition function
         compose_func = getattr(compose_module, self.composition_function)
 
-        # Execute the function with context
-        return compose_func(arguments, self.tooluniverse, self._call_tool)
+        # Import memory manager
+        from .memory_manager import memory_manager
+
+        # Execute the function with backward-compatible parameters
+        import inspect
+
+        sig = inspect.signature(compose_func)
+        params = list(sig.parameters.keys())
+
+        # Build arguments based on function signature
+        call_args = {
+            "arguments": arguments,
+            "tooluniverse": self.tooluniverse,
+            "call_tool": self._call_tool,
+        }
 
-    def _execute_inline_code(self, arguments):
+        # Add optional parameters if the function accepts them
+        if "stream_callback" in params:
+            call_args["stream_callback"] = stream_callback
+        if "emit_event" in params:
+            call_args["emit_event"] = self._create_event_emitter(stream_callback)
+        if "memory_manager" in params:
+            call_args["memory_manager"] = memory_manager
+
+        # Call with only the parameters the function expects
+        return compose_func(**{k: v for k, v in call_args.items() if k in params})
+
+    def _execute_inline_code(self, arguments, stream_callback=None):
         """
         Execute inline composition code (existing behavior).
 
         Args:
             arguments (dict): Input arguments
+            stream_callback (callable, optional): Callback function for streaming output
 
         Returns:
             Any: Result from the composition execution
@@ -368,4 +433,24 @@ class ComposeTool(BaseTool):
 
         function_call = {"name": tool_name, "arguments": arguments}
 
-        return self.tooluniverse.run_one_function(function_call)
+        result = self.tooluniverse.run_one_function(function_call)
+
+        # Ensure consistent result format for backward compatibility
+        if isinstance(result, str):
+            # If result is a string, it might be an error message or JSON string
+            try:
+                import json
+
+                parsed_result = json.loads(result)
+                if isinstance(parsed_result, dict):
+                    return parsed_result
+                else:
+                    return {"result": parsed_result}
+            except (json.JSONDecodeError, TypeError):
+                # If it's not JSON, treat as error message
+                return {"error": result}
+        elif isinstance(result, dict):
+            return result
+        else:
+            # For other types, wrap in a standard format
+            return {"result": result}

tooluniverse/core_tool.py

@@ -21,15 +21,18 @@ class CoreTool(BaseTool):
         super().__init__(tool_config)
         self.base_url = "https://api.core.ac.uk/v3"
         self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': 'ToolUniverse/1.0',
-            'Accept': 'application/json'
-        })
-
-    def _search(self, query: str, limit: int = 10,
-                year_from: Optional[int] = None,
-                year_to: Optional[int] = None,
-                language: Optional[str] = None) -> List[Dict[str, Any]]:
+        self.session.headers.update(
+            {"User-Agent": "ToolUniverse/1.0", "Accept": "application/json"}
+        )
+
+    def _search(
+        self,
+        query: str,
+        limit: int = 10,
+        year_from: Optional[int] = None,
+        year_to: Optional[int] = None,
+        language: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
         """
         Search for papers using CORE API.
 
@@ -46,9 +49,9 @@ class CoreTool(BaseTool):
         try:
             # Build search parameters
             params = {
-                'q': query,
-                'limit': min(limit, 100),  # CORE API max limit is 100
-                'page': 1
+                "q": query,
+                "limit": min(limit, 100),  # CORE API max limit is 100
+                "page": 1,
             }
 
             # Add year filters if provided
@@ -58,17 +61,15 @@ class CoreTool(BaseTool):
                     year_filter.append(f"year:>={year_from}")
                 if year_to:
                     year_filter.append(f"year:<={year_to}")
-                params['q'] += f" {' '.join(year_filter)}"
+                params["q"] += f" {' '.join(year_filter)}"
 
             # Add language filter if provided
             if language:
-                params['q'] += f" language:{language}"
+                params["q"] += f" language:{language}"
 
             # Make API request
             response = self.session.get(
-                f"{self.base_url}/search/works",
-                params=params,
-                timeout=30
+                f"{self.base_url}/search/works", params=params, timeout=30
             )
             response.raise_for_status()
 
@@ -76,30 +77,31 @@ class CoreTool(BaseTool):
             results = []
 
             # Parse results
-            for item in data.get('results', []):
+            for item in data.get("results", []):
                 paper = {
-                    'title': item.get('title', 'No title'),
-                    'abstract': item.get('abstract', 'No abstract available'),
-                    'authors': self._extract_authors(item.get('authors', [])),
-                    'year': self._extract_year(item.get('publishedDate')),
-                    'doi': item.get('doi'),
-                    'url': (item.get('downloadUrl') or
-                            item.get('links', [{}])[0].get('url')),
-                    'venue': item.get('publisher'),
-                    'language': item.get('language', {}).get('code', 'Unknown'),
-                    'open_access': True,  # CORE only contains open access papers
-                    'source': 'CORE',
-                    'citations': item.get('citationCount', 0),
-                    'downloads': item.get('downloadCount', 0)
+                    "title": item.get("title", "No title"),
+                    "abstract": item.get("abstract", "No abstract available"),
+                    "authors": self._extract_authors(item.get("authors", [])),
+                    "year": self._extract_year(item.get("publishedDate")),
+                    "doi": item.get("doi"),
+                    "url": (
+                        item.get("downloadUrl") or item.get("links", [{}])[0].get("url")
+                    ),
+                    "venue": item.get("publisher"),
+                    "language": item.get("language", {}).get("code", "Unknown"),
+                    "open_access": True,  # CORE only contains open access papers
+                    "source": "CORE",
+                    "citations": item.get("citationCount", 0),
+                    "downloads": item.get("downloadCount", 0),
                 }
                 results.append(paper)
 
             return results
 
         except requests.exceptions.RequestException as e:
-            return [{'error': f'CORE API request failed: {str(e)}'}]
+            return [{"error": f"CORE API request failed: {str(e)}"}]
         except Exception as e:
-            return [{'error': f'CORE API error: {str(e)}'}]
+            return [{"error": f"CORE API error: {str(e)}"}]
 
     def _extract_authors(self, authors: List[Dict]) -> List[str]:
         """Extract author names from CORE API response."""
@@ -108,7 +110,7 @@ class CoreTool(BaseTool):
 
         author_names = []
         for author in authors:
-            name = author.get('name', '')
+            name = author.get("name", "")
             if name:
                 author_names.append(name)
 
@@ -117,13 +119,13 @@ class CoreTool(BaseTool):
     def _extract_year(self, published_date: str) -> str:
         """Extract year from published date."""
         if not published_date:
-            return 'Unknown'
+            return "Unknown"
 
         try:
             # CORE API returns dates in ISO format
             return published_date[:4]
         except Exception:
-            return 'Unknown'
+            return "Unknown"
 
     def run(self, tool_arguments) -> List[Dict[str, Any]]:
         """
@@ -135,19 +137,19 @@ class CoreTool(BaseTool):
         Returns:
             List of paper dictionaries
         """
-        query = tool_arguments.get('query', '')
+        query = tool_arguments.get("query", "")
         if not query:
-            return [{'error': 'Query parameter is required'}]
+            return [{"error": "Query parameter is required"}]
 
-        limit = tool_arguments.get('limit', 10)
-        year_from = tool_arguments.get('year_from')
-        year_to = tool_arguments.get('year_to')
-        language = tool_arguments.get('language')
+        limit = tool_arguments.get("limit", 10)
+        year_from = tool_arguments.get("year_from")
+        year_to = tool_arguments.get("year_to")
+        language = tool_arguments.get("language")
 
         return self._search(
             query=query,
             limit=limit,
             year_from=year_from,
             year_to=year_to,
-            language=language
-        )
+            language=language,
+        )

tooluniverse/crossref_tool.py

@@ -48,25 +48,110 @@ class CrossrefTool(BaseTool):
         data = response.json().get("message", {}).get("items", [])
         results = []
         for item in data:
+            # Extract title
             title_list = item.get("title") or []
             title = title_list[0] if title_list else None
+
+            # Extract abstract
             abstract = item.get("abstract")
+            if abstract and isinstance(abstract, str):
+                # Clean HTML tags
+                import re
+
+                abstract = re.sub(r"<[^>]+>", "", abstract)
+                abstract = abstract.strip()
+
+            # Extract author information
+            authors = []
+            author_list = item.get("author", [])
+            if isinstance(author_list, list):
+                for author in author_list:
+                    if isinstance(author, dict):
+                        given = author.get("given", "")
+                        family = author.get("family", "")
+                        if given and family:
+                            authors.append(f"{given} {family}")
+                        elif family:
+                            authors.append(family)
+
+            # Extract year
             year = None
             issued = item.get("issued", {}).get("date-parts") or []
             if issued and issued[0]:
                 year = issued[0][0]
+
+            # Extract URL and DOI
             url = item.get("URL")
             doi = item.get("DOI")
+
+            # Extract journal information
             container_title = item.get("container-title") or []
             journal = container_title[0] if container_title else None
+
+            # Extract citation count
+            citations = item.get("is-referenced-by-count", 0)
+            if citations:
+                try:
+                    citations = int(citations)
+                except (ValueError, TypeError):
+                    citations = 0
+
+            # Extract open access status
+            open_access = item.get(
+                "is-referenced-by-count", 0
+            )  # This field might not be accurate
+            # Try to get open access status from license information
+            license_info = item.get("license", [])
+            if isinstance(license_info, list) and license_info:
+                open_access = (
+                    True  # If there's license information, it might be open access
+                )
+
+            # Extract keywords
+            keywords = []
+            subject_list = item.get("subject", [])
+            if isinstance(subject_list, list):
+                keywords.extend(subject_list)
+
+            # Extract article type
+            article_type = item.get("type", "Unknown")
+
+            # Extract publisher
+            publisher = item.get("publisher", "Unknown")
+
+            # Handle missing abstract
+            if not abstract:
+                abstract = "Abstract not available"
+
             results.append(
                 {
-                    "title": title,
+                    "title": title or "Title not available",
                     "abstract": abstract,
-                    "journal": journal,
+                    "authors": (
+                        authors if authors else "Author information not available"
+                    ),
+                    "journal": journal or "Journal information not available",
                     "year": year,
-                    "doi": doi,
-                    "url": url,
+                    "doi": doi or "DOI not available",
+                    "url": url or "URL not available",
+                    "citations": citations,
+                    "open_access": open_access,
+                    "keywords": keywords if keywords else "Keywords not available",
+                    "article_type": article_type,
+                    "publisher": publisher,
+                    "source": "Crossref",
+                    "data_quality": {
+                        "has_abstract": bool(
+                            abstract and abstract != "Abstract not available"
+                        ),
+                        "has_authors": bool(authors),
+                        "has_journal": bool(journal),
+                        "has_year": bool(year),
+                        "has_doi": bool(doi),
+                        "has_citations": bool(citations and citations > 0),
+                        "has_keywords": bool(keywords),
+                        "has_url": bool(url),
+                    },
                 }
             )
 

tooluniverse/custom_tool.py

@@ -26,6 +26,11 @@ class CustomTool(BaseTool):
         self.execute_function = None
         if self.code_file and os.path.exists(self.code_file):
             self._load_external_code()
+        elif (
+            "implementation" in tool_config
+            and "source_code" in tool_config["implementation"]
+        ):
+            self._load_embedded_code(tool_config["implementation"])
 
     def _load_external_code(self):
         """Load the execute_tool function from external Python file"""
@@ -46,6 +51,29 @@ class CustomTool(BaseTool):
         except Exception as e:
             print(f"Error loading external code from {self.code_file}: {e}")
 
+    def _load_embedded_code(self, implementation: Dict):
+        """Load the execute_tool function from embedded source code"""
+        try:
+            source_code = implementation.get("source_code", "")
+            main_function = implementation.get("main_function", "execute_tool")
+
+            # Create a temporary module to execute the code
+            import types
+
+            module = types.ModuleType("embedded_tool_module")
+
+            # Execute the source code in the module namespace
+            exec(source_code, module.__dict__)
+
+            # Get the main function
+            if hasattr(module, main_function):
+                self.execute_function = getattr(module, main_function)
+            else:
+                print(f"Warning: No {main_function} function found in embedded code")
+
+        except Exception as e:
+            print(f"Error loading embedded code: {e}")
+
     def run(self, arguments: Any = None) -> Dict[str, Any]:
         """
         Execute the custom tool