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

janito/tools/adapters/local/fetch_url.py

@@ -68,19 +68,21 @@ class FetchUrlTool(ToolBase):
             {}
         )  # In-memory session cache - lifetime matches tool instance
         self._load_cache()
-        
+
         # Browser-like session with cookies and headers
         self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'DNT': '1',
-            'Connection': 'keep-alive',
-            'Upgrade-Insecure-Requests': '1',
-        })
-        
+        self.session.headers.update(
+            {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.5",
+                "Accept-Encoding": "gzip, deflate, br",
+                "DNT": "1",
+                "Connection": "keep-alive",
+                "Upgrade-Insecure-Requests": "1",
+            }
+        )
+
         # Load cookies from disk if they exist
         self.cookies_file = self.cache_dir / "cookies.json"
         self._load_cookies()
@@ -120,12 +122,14 @@ class FetchUrlTool(ToolBase):
         try:
             cookies_data = []
             for cookie in self.session.cookies:
-                cookies_data.append({
-                    'name': cookie.name,
-                    'value': cookie.value,
-                    'domain': cookie.domain,
-                    'path': cookie.path
-                })
+                cookies_data.append(
+                    {
+                        "name": cookie.name,
+                        "value": cookie.value,
+                        "domain": cookie.domain,
+                        "path": cookie.path,
+                    }
+                )
             with open(self.cookies_file, "w", encoding="utf-8") as f:
                 json.dump(cookies_data, f, indent=2)
         except IOError:
@@ -170,8 +174,14 @@ class FetchUrlTool(ToolBase):
         }
         self._save_cache()
 
-    def _fetch_url_content(self, url: str, timeout: int = 10, headers: Optional[Dict[str, str]] = None, 
-                          cookies: Optional[Dict[str, str]] = None, follow_redirects: bool = True) -> str:
+    def _fetch_url_content(
+        self,
+        url: str,
+        timeout: int = 10,
+        headers: Optional[Dict[str, str]] = None,
+        cookies: Optional[Dict[str, str]] = None,
+        follow_redirects: bool = True,
+    ) -> str:
         """Fetch URL content and handle HTTP errors.
 
         Implements two-tier caching:
@@ -224,23 +234,23 @@ class FetchUrlTool(ToolBase):
             request_headers = self.session.headers.copy()
             if headers:
                 request_headers.update(headers)
-            
+
             # Merge custom cookies
             if cookies:
                 self.session.cookies.update(cookies)
 
             response = self.session.get(
-                url, 
-                timeout=timeout, 
+                url,
+                timeout=timeout,
                 headers=request_headers,
-                allow_redirects=follow_redirects
+                allow_redirects=follow_redirects,
             )
             response.raise_for_status()
             content = response.text
-            
+
             # Save cookies after successful request
             self._save_cookies()
-            
+
             # Cache successful responses in session cache
             self.session_cache[url] = content
             return content
@@ -354,8 +364,11 @@ class FetchUrlTool(ToolBase):
         # Check if we should save to file
         if save_to_file:
             html_content = self._fetch_url_content(
-                url, timeout=timeout, headers=headers, cookies=cookies, 
-                follow_redirects=follow_redirects
+                url,
+                timeout=timeout,
+                headers=headers,
+                cookies=cookies,
+                follow_redirects=follow_redirects,
             )
             if html_content.startswith("Warning:"):
                 return html_content
@@ -380,8 +393,11 @@ class FetchUrlTool(ToolBase):
 
         # Normal processing path
         html_content = self._fetch_url_content(
-            url, timeout=timeout, headers=headers, cookies=cookies, 
-            follow_redirects=follow_redirects
+            url,
+            timeout=timeout,
+            headers=headers,
+            cookies=cookies,
+            follow_redirects=follow_redirects,
         )
         if html_content.startswith("Warning:"):
             return html_content

janito/tools/adapters/local/python_command_run.py

@@ -32,7 +32,8 @@ class PythonCommandRunTool(ToolBase):
             return tr("Warning: Empty code provided. Operation skipped.")
         if not silent:
             self.report_action(
-                tr("🐍 Running: python -c ...\n{code}\n", code=code), ReportAction.EXECUTE
+                tr("🐍 Running: python -c ...\n{code}\n", code=code),
+                ReportAction.EXECUTE,
             )
             self.report_stdout("\n")
         else:

janito/tools/adapters/local/python_file_run.py

@@ -28,6 +28,7 @@ class PythonFileRunTool(ToolBase):
 
     def run(self, path: str, timeout: int = 60, silent: bool = False) -> str:
         from janito.tools.path_utils import expand_path
+
         path = expand_path(path)
         if not silent:
             self.report_action(

janito/tools/adapters/local/run_powershell_command.py

@@ -43,7 +43,7 @@ class RunPowershellCommandTool(ToolBase):
         if require_confirmation:
             self.report_warning(
                 tr("⚠️ Confirmation requested, but no handler (auto-confirmed)."),
-                ReportAction.EXECUTE
+                ReportAction.EXECUTE,
             )
             return True  # Auto-confirm for now
         return True

janito/tools/adapters/local/validate_file_syntax/jinja2_validator.py

@@ -8,40 +8,43 @@ def validate_jinja2(path: str) -> str:
     """Validate Jinja2 template syntax."""
     try:
         from jinja2 import Environment, TemplateSyntaxError
-        
+
         with open(path, "r", encoding="utf-8") as f:
             content = f.read()
-        
+
         # Create a Jinja2 environment and try to parse the template
         env = Environment()
         try:
             env.parse(content)
             return tr("✅ Syntax OK")
         except TemplateSyntaxError as e:
-            line_num = getattr(e, 'lineno', 0)
-            return tr("⚠️ Warning: Syntax error: {error} at line {line}", 
-                     error=str(e), line=line_num)
+            line_num = getattr(e, "lineno", 0)
+            return tr(
+                "⚠️ Warning: Syntax error: {error} at line {line}",
+                error=str(e),
+                line=line_num,
+            )
         except Exception as e:
             return tr("⚠️ Warning: Syntax error: {error}", error=str(e))
-            
+
     except ImportError:
         # If jinja2 is not available, just check basic structure
         try:
             with open(path, "r", encoding="utf-8") as f:
                 content = f.read()
-            
+
             # Basic checks for common Jinja2 syntax issues
             open_tags = content.count("{%")
             close_tags = content.count("%}")
             open_vars = content.count("{{")
             close_vars = content.count("}}")
-            
+
             if open_tags != close_tags:
                 return tr("⚠️ Warning: Syntax error: Mismatched Jinja2 tags")
             if open_vars != close_vars:
                 return tr("⚠️ Warning: Syntax error: Mismatched Jinja2 variables")
-                
+
             return tr("✅ Syntax OK (basic validation)")
-            
+
         except Exception as e:
-            return tr("⚠️ Warning: Syntax error: {error}", error=str(e))
+            return tr("⚠️ Warning: Syntax error: {error}", error=str(e))

janito/tools/base.py

@@ -1,11 +1,12 @@
 class BaseTool:
     """Base class for all tools."""
+
     tool_name: str = ""
-    
+
     def __init__(self):
         if not self.tool_name:
             self.tool_name = self.__class__.__name__.lower()
-    
+
     def run(self, *args, **kwargs) -> str:
         """Execute the tool."""
-        raise NotImplementedError
+        raise NotImplementedError

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.29.0.dist-info}/METADATA

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