janito 2.27.1__py3-none-any.whl → 2.28.0__py3-none-any.whl

janito/tools/loop_protection.py

@@ -8,19 +8,19 @@ class LoopProtection:
     """
     Provides loop protection for tool calls by tracking repeated operations
     on the same resources within a short time period.
-    
+
     This class monitors file operations and prevents excessive reads on the same
     file within a configurable time window. It helps prevent infinite loops or
     excessive resource consumption when tools repeatedly access the same files.
-    
+
     The default configuration allows up to 5 operations on the same file within
     a 10-second window. Operations outside this window are automatically cleaned
     up to prevent memory accumulation.
     """
-    
+
     _instance = None
     _lock = threading.Lock()
-    
+
     def __new__(cls):
         if not cls._instance:
             with cls._lock:
@@ -28,7 +28,7 @@ class LoopProtection:
                     cls._instance = super().__new__(cls)
                     cls._instance._init_protection()
         return cls._instance
-    
+
     def _init_protection(self):
         # Track file operations: {normalized_path: [(timestamp, operation_type), ...]}
         self._file_operations: Dict[str, List[Tuple[float, str]]] = {}
@@ -36,7 +36,7 @@ class LoopProtection:
         self._time_window = 10.0
         # Maximum allowed operations on the same file within time window
         self._max_operations = 5
-        
+
         """
         Configuration parameters:
         
@@ -46,23 +46,23 @@ class LoopProtection:
         _max_operations: Maximum number of operations allowed on the same file
                         within the time window. Default is 5 operations.
         """
-        
+
     def check_file_operation_limit(self, path: str, operation_type: str) -> bool:
         """
         Check if performing an operation on a file would exceed the limit.
-        
+
         This method tracks file operations and prevents excessive reads on the same
         file within a configurable time window (default 10 seconds). It helps prevent
         infinite loops or excessive resource consumption when tools repeatedly access
         the same files.
-        
+
         Args:
             path: The file path being operated on
             operation_type: Type of operation (e.g., "view_file", "read_files")
-            
+
         Returns:
             bool: True if operation is allowed, False if it would exceed the limit
-            
+
         Example:
             >>> loop_protection = LoopProtection.instance()
             >>> if loop_protection.check_file_operation_limit("/path/to/file.txt", "view_file"):
@@ -74,42 +74,44 @@ class LoopProtection:
         """
         norm_path = normalize_path(path)
         current_time = time.time()
-        
+
         # Clean up old operations outside the time window
         if norm_path in self._file_operations:
             self._file_operations[norm_path] = [
-                (timestamp, op_type) 
+                (timestamp, op_type)
                 for timestamp, op_type in self._file_operations[norm_path]
                 if current_time - timestamp <= self._time_window
             ]
-        
+
         # Check if we're exceeding the limit
         if norm_path in self._file_operations:
             operations = self._file_operations[norm_path]
             if len(operations) >= self._max_operations:
                 # Check if all recent operations are within the time window
-                if all(current_time - timestamp <= self._time_window 
-                      for timestamp, _ in operations):
+                if all(
+                    current_time - timestamp <= self._time_window
+                    for timestamp, _ in operations
+                ):
                     return False  # Would exceed limit - potential loop
-        
+
         # Record this operation
         if norm_path not in self._file_operations:
             self._file_operations[norm_path] = []
         self._file_operations[norm_path].append((current_time, operation_type))
-        
+
         return True  # Operation allowed
-    
+
     def reset_tracking(self):
         """
         Reset all tracking data.
-        
+
         This method clears all recorded file operations, effectively resetting
         the loop protection state. This can be useful in testing scenarios or
         when you want to explicitly clear the tracking history.
         """
         with self._lock:
             self._file_operations.clear()
-    
+
     @classmethod
     def instance(cls):
-        return cls()
+        return cls()

janito/tools/path_utils.py

@@ -9,19 +9,19 @@ from pathlib import Path
 def expand_path(path: str) -> str:
     """
     Expand a path, handling tilde (~) expansion for user home directory.
-    
+
     Args:
         path (str): The path to expand.
-        
+
     Returns:
         str: The expanded absolute path.
     """
     if not path:
         return path
-    
+
     # Handle tilde expansion
     expanded = os.path.expanduser(path)
-    
+
     # Convert to absolute path
     return os.path.abspath(expanded)
 
@@ -29,11 +29,11 @@ def expand_path(path: str) -> str:
 def normalize_path(path: str) -> str:
     """
     Normalize a path by expanding tilde and resolving any relative paths.
-    
+
     Args:
         path (str): The path to normalize.
-        
+
     Returns:
         str: The normalized absolute path.
     """
-    return expand_path(path)
+    return expand_path(path)

janito/tools/tool_base.py

@@ -112,5 +112,3 @@ class ToolBase:
 
     def run(self, *args, **kwargs):
         raise NotImplementedError("Subclasses must implement the run method.")
-
-

janito/tools/tools_adapter.py

@@ -150,11 +150,17 @@ class ToolsAdapterBase:
             unexpected = [k for k in arguments.keys() if k not in params]
             if unexpected:
                 # Build detailed error message with received arguments
-                error_parts = ["Unexpected argument(s): " + ", ".join(sorted(unexpected))]
-                error_parts.append("Valid parameters: " + ", ".join(sorted(params.keys())))
+                error_parts = [
+                    "Unexpected argument(s): " + ", ".join(sorted(unexpected))
+                ]
+                error_parts.append(
+                    "Valid parameters: " + ", ".join(sorted(params.keys()))
+                )
                 error_parts.append("Arguments received:")
                 for key, value in arguments.items():
-                    error_parts.append(f"  {key}: {repr(value)} ({type(value).__name__})")
+                    error_parts.append(
+                        f"  {key}: {repr(value)} ({type(value).__name__})"
+                    )
                 return "\n".join(error_parts)
 
         # Check for missing required arguments (ignoring *args / **kwargs / self)
@@ -172,11 +178,15 @@ class ToolsAdapterBase:
         missing = [name for name in required_params if name not in arguments]
         if missing:
             # Build detailed error message with received arguments
-            error_parts = ["Missing required argument(s): " + ", ".join(sorted(missing))]
+            error_parts = [
+                "Missing required argument(s): " + ", ".join(sorted(missing))
+            ]
             error_parts.append("Arguments received:")
             if isinstance(arguments, dict):
                 for key, value in arguments.items():
-                    error_parts.append(f"  {key}: {repr(value)} ({type(value).__name__})")
+                    error_parts.append(
+                        f"  {key}: {repr(value)} ({type(value).__name__})"
+                    )
             elif arguments is not None:
                 error_parts.append(f"  {repr(arguments)} ({type(arguments).__name__})")
             else:

janito/tools/url_whitelist.py

@@ -8,102 +8,102 @@ from urllib.parse import urlparse
 
 class UrlWhitelistManager:
     """Manages allowed sites for the fetch_url tool."""
-    
+
     def __init__(self):
         self.config_path = Path.home() / ".janito" / "url_whitelist.json"
         self._allowed_sites = self._load_whitelist()
         self._unrestricted_mode = False
-    
+
     def set_unrestricted_mode(self, enabled: bool = True):
         """Enable or disable unrestricted mode (bypasses whitelist)."""
         self._unrestricted_mode = enabled
-    
+
     def _load_whitelist(self) -> Set[str]:
         """Load the whitelist from config file."""
         if not self.config_path.exists():
             return set()
-        
+
         try:
-            with open(self.config_path, 'r', encoding='utf-8') as f:
+            with open(self.config_path, "r", encoding="utf-8") as f:
                 data = json.load(f)
-                return set(data.get('allowed_sites', []))
+                return set(data.get("allowed_sites", []))
         except (json.JSONDecodeError, IOError):
             return set()
-    
+
     def _save_whitelist(self):
         """Save the whitelist to config file."""
         self.config_path.parent.mkdir(parents=True, exist_ok=True)
         try:
-            with open(self.config_path, 'w', encoding='utf-8') as f:
-                json.dump({'allowed_sites': list(self._allowed_sites)}, f, indent=2)
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                json.dump({"allowed_sites": list(self._allowed_sites)}, f, indent=2)
         except IOError:
             pass  # Silently fail if we can't write
-    
+
     def is_url_allowed(self, url: str) -> bool:
         """Check if a URL is allowed based on the whitelist."""
         if self._unrestricted_mode:
             return True  # Unrestricted mode bypasses all whitelist checks
-        
+
         if not self._allowed_sites:
             return True  # No whitelist means all sites allowed
-        
+
         try:
             parsed = urlparse(url)
             domain = parsed.netloc.lower()
-            
+
             # Check exact matches and subdomain matches
             for allowed in self._allowed_sites:
                 allowed = allowed.lower()
-                if domain == allowed or domain.endswith('.' + allowed):
+                if domain == allowed or domain.endswith("." + allowed):
                     return True
-            
+
             return False
         except Exception:
             return False  # Invalid URLs are blocked
-    
+
     def add_allowed_site(self, site: str) -> bool:
         """Add a site to the whitelist."""
         # Clean up the site format
         site = site.strip().lower()
-        if site.startswith('http://') or site.startswith('https://'):
+        if site.startswith("http://") or site.startswith("https://"):
             parsed = urlparse(site)
             site = parsed.netloc
-        
+
         if site and site not in self._allowed_sites:
             self._allowed_sites.add(site)
             self._save_whitelist()
             return True
         return False
-    
+
     def remove_allowed_site(self, site: str) -> bool:
         """Remove a site from the whitelist."""
         site = site.strip().lower()
-        if site.startswith('http://') or site.startswith('https://'):
+        if site.startswith("http://") or site.startswith("https://"):
             parsed = urlparse(site)
             site = parsed.netloc
-        
+
         if site in self._allowed_sites:
             self._allowed_sites.remove(site)
             self._save_whitelist()
             return True
         return False
-    
+
     def get_allowed_sites(self) -> List[str]:
         """Get the list of allowed sites."""
         return sorted(self._allowed_sites)
-    
+
     def set_allowed_sites(self, sites: List[str]):
         """Set the complete list of allowed sites."""
         self._allowed_sites = set()
         for site in sites:
             site = site.strip().lower()
-            if site.startswith('http://') or site.startswith('https://'):
+            if site.startswith("http://") or site.startswith("https://"):
                 parsed = urlparse(site)
                 site = parsed.netloc
             if site:
                 self._allowed_sites.add(site)
         self._save_whitelist()
-    
+
     def clear_whitelist(self):
         """Clear all allowed sites."""
         self._allowed_sites.clear()
@@ -113,9 +113,10 @@ class UrlWhitelistManager:
 # Global singleton
 _url_whitelist_manager = None
 
+
 def get_url_whitelist_manager() -> UrlWhitelistManager:
     """Get the global URL whitelist manager instance."""
     global _url_whitelist_manager
     if _url_whitelist_manager is None:
         _url_whitelist_manager = UrlWhitelistManager()
-    return _url_whitelist_manager
+    return _url_whitelist_manager

{janito-2.27.1.dist-info → janito-2.28.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.27.1
+Version: 2.28.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito