janito 2.32.0__tar.gz → 2.33.0__tar.gz

{janito-2.32.0 → janito-2.33.0}/PKG-INFO

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

{janito-2.32.0 → janito-2.33.0}/janito/agent/setup_agent.py

@@ -155,6 +155,32 @@ def _prepare_template_context(role, profile, allowed_permissions, args=None):
         getattr(args, "emoji", False) if "args" in locals() else False
     )
 
+    # Add current date/time with timezone using standard library
+    from datetime import datetime, timezone
+    import time
+
+    # Get local time with timezone info
+    local_time = datetime.now()
+
+    # Get timezone offset
+    if time.daylight:
+        offset = time.altzone
+    else:
+        offset = time.timezone
+
+    # Format offset as +HHMM or -HHMM
+    offset_hours = -offset // 3600
+    offset_minutes = abs(offset) % 3600 // 60
+    offset_str = f"{offset_hours:+03d}{offset_minutes:02d}"
+
+    # Get timezone name
+    tz_name = time.tzname[time.daylight and time.daylight or 0]
+
+    context["current_datetime"] = local_time.strftime(
+        f"%Y-%m-%d %H:%M:%S {tz_name}{offset_str}"
+    )
+    context["timezone"] = f"{tz_name} (UTC{offset_str})"
+
     return context
 
 

{janito-2.32.0 → janito-2.33.0}/janito/agent/templates/profiles/system_prompt_template_Developer_with_Python_Tools.txt.j2

@@ -4,6 +4,8 @@
 {% if description %}Description: {{ description }}{% endif %}
 {% if author %}Author: {{ author }}{% endif %}
 {% if tags %}Tags: {{ tags | join(', ') }}{% endif %}
+{% if current_datetime %}Current Date/Time: {{ current_datetime }}{% endif %}
+{% if timezone %}Timezone: {{ timezone }}{% endif %}
 
 {# General role setup
   ex. "Search in code" -> Python Developer -> find(*.py) | Java Developer -> find(*.java)

{janito-2.32.0 → janito-2.33.0}/janito/agent/templates/profiles/system_prompt_template_developer.txt.j2

@@ -4,6 +4,8 @@
 {% if description %}Description: {{ description }}{% endif %}
 {% if author %}Author: {{ author }}{% endif %}
 {% if tags %}Tags: {{ tags | join(', ') }}{% endif %}
+{% if current_datetime %}Current Date/Time: {{ current_datetime }}{% endif %}
+{% if timezone %}Timezone: {{ timezone }}{% endif %}
 
 You are: {{ role | default('software developer') }}
 

{janito-2.32.0 → janito-2.33.0}/janito/agent/templates/profiles/system_prompt_template_market_analyst.txt.j2

@@ -4,6 +4,8 @@
 {% if description %}Description: {{ description }}{% endif %}
 {% if author %}Author: {{ author }}{% endif %}
 {% if tags %}Tags: {{ tags | join(', ') }}{% endif %}
+{% if current_datetime %}Current Date/Time: {{ current_datetime }}{% endif %}
+{% if timezone %}Timezone: {{ timezone }}{% endif %}
 
 You are: {{ role | default('market analyst specializing in financial markets, business intelligence, and economic research') }}
 

{janito-2.32.0 → janito-2.33.0}/janito/agent/templates/profiles/system_prompt_template_model_conversation_without_tools_or_context.txt.j2

@@ -4,6 +4,8 @@
 {% if description %}Description: {{ description }}{% endif %}
 {% if author %}Author: {{ author }}{% endif %}
 {% if tags %}Tags: {{ tags | join(', ') }}{% endif %}
+{% if current_datetime %}Current Date/Time: {{ current_datetime }}{% endif %}
+{% if timezone %}Timezone: {{ timezone }}{% endif %}
 
 You are: {{ role | default('helpful assistant') }}
 

{janito-2.32.0 → janito-2.33.0}/janito/tools/adapters/local/fetch_url.py

@@ -246,11 +246,11 @@ class FetchUrlTool(ToolBase):
             return content
         except requests.exceptions.HTTPError as http_err:
             status_code = http_err.response.status_code if http_err.response else None
-            
+
             # Map status codes to descriptions
             status_descriptions = {
                 400: "Bad Request",
-                401: "Unauthorized", 
+                401: "Unauthorized",
                 403: "Forbidden",
                 404: "Not Found",
                 405: "Method Not Allowed",
@@ -266,50 +266,68 @@ class FetchUrlTool(ToolBase):
                 502: "Bad Gateway",
                 503: "Service Unavailable",
                 504: "Gateway Timeout",
-                505: "HTTP Version Not Supported"
+                505: "HTTP Version Not Supported",
             }
-            
+
             if status_code and 400 <= status_code < 500:
                 description = status_descriptions.get(status_code, "Client Error")
-                error_message = tr(
-                    "HTTP Error {status_code} {description}",
-                    status_code=status_code,
-                    description=description,
-                )
+                error_message = f"HTTP {status_code} {description}"
                 # Cache 403 and 404 errors
                 if status_code in [403, 404]:
                     self._cache_error(url, status_code, error_message)
 
                 self.report_error(
-                    tr(
-                        "❗ HTTP Error {status_code} {description}",
-                        status_code=status_code,
-                        description=description,
-                    ),
+                    f"❗ HTTP {status_code} {description}",
                     ReportAction.READ,
                 )
                 return error_message
-            else:
-                description = status_descriptions.get(status_code, "Server Error") if status_code else "Error"
+            elif status_code and 500 <= status_code < 600:
+                description = status_descriptions.get(status_code, "Server Error")
+                error_message = f"HTTP {status_code} {description}"
                 self.report_error(
-                    tr(
-                        "❗ HTTP Error {status_code} {description}",
-                        status_code=status_code or "Error",
-                        description=description,
-                    ),
+                    f"❗ HTTP {status_code} {description}",
                     ReportAction.READ,
                 )
-                return tr(
-                    "HTTP Error {status_code} {description}",
-                    status_code=status_code or "Error",
-                    description=description,
+                return error_message
+            else:
+                status_code_str = str(status_code) if status_code else "Error"
+                description = status_descriptions.get(
+                    status_code,
+                    (
+                        "Server Error"
+                        if status_code and status_code >= 500
+                        else "Client Error"
+                    ),
                 )
+                self.report_error(
+                    f"❗ HTTP {status_code_str} {description}",
+                    ReportAction.READ,
+                )
+                return f"HTTP {status_code_str} {description}"
+        except requests.exceptions.ConnectionError as conn_err:
+            self.report_error(
+                "❗ Network Error",
+                ReportAction.READ,
+            )
+            return f"Network Error: Failed to connect to {url}"
+        except requests.exceptions.Timeout as timeout_err:
+            self.report_error(
+                "❗ Timeout Error",
+                ReportAction.READ,
+            )
+            return f"Timeout Error: Request timed out after {timeout} seconds"
+        except requests.exceptions.RequestException as req_err:
+            self.report_error(
+                "❗ Request Error",
+                ReportAction.READ,
+            )
+            return f"Request Error: {str(req_err)}"
         except Exception as err:
             self.report_error(
-                tr("❗ Error"),
+                "❗ Error fetching URL",
                 ReportAction.READ,
             )
-            return tr("Error")
+            return f"Error: {str(err)}"
 
     def _extract_and_clean_text(self, html_content: str) -> str:
         """Extract and clean text from HTML content."""

{janito-2.32.0 → janito-2.33.0}/janito.egg-info/PKG-INFO

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

{janito-2.32.0 → janito-2.33.0}/janito.egg-info/SOURCES.txt

@@ -23,6 +23,8 @@ requirements-dev.txt
 requirements.txt
 test.txt
 test_example.py
+test_http_errors.py
+test_http_errors_direct.py
 test_key_field_behavior.py
 test_key_field_protection.py
 test_loop_protection_return.py

{janito-2.32.0 → janito-2.33.0}/plugins/web/webtools/tools/fetch_url.py

@@ -246,11 +246,11 @@ class FetchUrlTool(ToolBase):
             return content
         except requests.exceptions.HTTPError as http_err:
             status_code = http_err.response.status_code if http_err.response else None
-            
+
             # Map status codes to descriptions
             status_descriptions = {
                 400: "Bad Request",
-                401: "Unauthorized", 
+                401: "Unauthorized",
                 403: "Forbidden",
                 404: "Not Found",
                 405: "Method Not Allowed",
@@ -266,50 +266,60 @@ class FetchUrlTool(ToolBase):
                 502: "Bad Gateway",
                 503: "Service Unavailable",
                 504: "Gateway Timeout",
-                505: "HTTP Version Not Supported"
+                505: "HTTP Version Not Supported",
             }
-            
+
             if status_code and 400 <= status_code < 500:
                 description = status_descriptions.get(status_code, "Client Error")
-                error_message = tr(
-                    "HTTP Error {status_code} {description}",
-                    status_code=status_code,
-                    description=description,
-                )
+                error_message = f"HTTP {status_code} {description}"
                 # Cache 403 and 404 errors
                 if status_code in [403, 404]:
                     self._cache_error(url, status_code, error_message)
 
                 self.report_error(
-                    tr(
-                        "❗ HTTP Error {status_code} {description}",
-                        status_code=status_code,
-                        description=description,
-                    ),
+                    f"❗ HTTP {status_code} {description}",
                     ReportAction.READ,
                 )
                 return error_message
             else:
-                description = status_descriptions.get(status_code, "Server Error") if status_code else "Error"
-                self.report_error(
-                    tr(
-                        "❗ HTTP Error {status_code} {description}",
-                        status_code=status_code or "Error",
-                        description=description,
+                status_code_str = str(status_code) if status_code else "Error"
+                description = status_descriptions.get(
+                    status_code,
+                    (
+                        "Server Error"
+                        if status_code and status_code >= 500
+                        else "Client Error"
                     ),
-                    ReportAction.READ,
                 )
-                return tr(
-                    "HTTP Error {status_code} {description}",
-                    status_code=status_code or "Error",
-                    description=description,
+                self.report_error(
+                    f"❗ HTTP {status_code_str} {description}",
+                    ReportAction.READ,
                 )
+                return f"HTTP {status_code_str} {description}"
+        except requests.exceptions.ConnectionError as conn_err:
+            self.report_error(
+                "❗ Network Error",
+                ReportAction.READ,
+            )
+            return f"Network Error: Failed to connect to {url}"
+        except requests.exceptions.Timeout as timeout_err:
+            self.report_error(
+                "❗ Timeout Error",
+                ReportAction.READ,
+            )
+            return f"Timeout Error: Request timed out after {timeout} seconds"
+        except requests.exceptions.RequestException as req_err:
+            self.report_error(
+                "❗ Request Error",
+                ReportAction.READ,
+            )
+            return f"Request Error: {str(req_err)}"
         except Exception as err:
             self.report_error(
-                tr("❗ Error"),
+                "❗ Error fetching URL",
                 ReportAction.READ,
             )
-            return tr("Error")
+            return f"Error: {str(err)}"
 
     def _extract_and_clean_text(self, html_content: str) -> str:
         """Extract and clean text from HTML content."""

janito-2.33.0/test_http_errors.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Test file to check HTTP error handling in janito's fetch_url functionality.
+This test will attempt to fetch URLs that should return various HTTP errors.
+"""
+
+import pytest
+import sys
+import os
+
+# Add the janito package to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "."))
+
+from janito.tools.adapters.local.fetch_url import FetchUrlTool
+
+
+class TestHttpErrors:
+    """Test HTTP error handling in fetch_url functionality."""
+
+    def test_404_error(self):
+        """Test handling of 404 Not Found errors."""
+        fetcher = FetchUrlTool()
+
+        # Use a URL that should return 404
+        result = fetcher.run("https://httpstat.us/404")
+
+        # Should contain error information
+        assert "HTTP Error" in result or "404" in result or "Not Found" in result
+        print(f"404 test result: {result}")
+
+    def test_403_error(self):
+        """Test handling of 403 Forbidden errors."""
+        fetcher = FetchUrlTool()
+
+        # Use a URL that should return 403
+        result = fetcher.run("https://httpstat.us/403")
+
+        # Should contain error information
+        assert "HTTP Error" in result or "403" in result or "Forbidden" in result
+        print(f"403 test result: {result}")
+
+    def test_500_error(self):
+        """Test handling of 500 Internal Server Error."""
+        fetcher = FetchUrlTool()
+
+        # Use a URL that should return 500
+        result = fetcher.run("https://httpstat.us/500")
+
+        # Should contain error information
+        assert "HTTP Error" in result or "500" in result or "Server Error" in result
+        print(f"500 test result: {result}")
+
+    def test_timeout_error(self):
+        """Test handling of timeout errors."""
+        fetcher = FetchUrlTool()
+
+        # Use a URL that delays response and set short timeout
+        result = fetcher.run("https://httpstat.us/200?sleep=5000", timeout=1)
+
+        # Should contain timeout or error information
+        assert "timeout" in result.lower() or "error" in result.lower()
+        print(f"Timeout test result: {result}")
+
+    def test_invalid_url_error(self):
+        """Test handling of invalid URLs."""
+        fetcher = FetchUrlTool()
+
+        # Use an invalid URL
+        result = fetcher.run("https://this-domain-does-not-exist-12345.com")
+
+        # Should contain error information
+        assert "error" in result.lower() or "failed" in result.lower()
+        print(f"Invalid URL test result: {result}")
+
+    def test_blocked_url(self):
+        """Test handling of blocked URLs (whitelist functionality)."""
+        fetcher = FetchUrlTool()
+
+        # Try to fetch a URL that might be blocked
+        # Note: This depends on the current whitelist configuration
+        result = fetcher.run("http://malware-testing.com")
+
+        # Should contain blocked information or proceed normally
+        print(f"Blocked URL test result: {result}")
+
+    def test_successful_request(self):
+        """Test that successful requests still work."""
+        fetcher = FetchUrlTool()
+
+        # Use a URL that should return 200
+        result = fetcher.run("https://httpstat.us/200")
+
+        # Should contain the expected content
+        assert "200" in result or "OK" in result
+        print(f"Successful request test result: {result[:100]}...")
+
+
+if __name__ == "__main__":
+    # Run tests when executed directly
+    pytest.main([__file__, "-v", "-s"])

janito-2.33.0/test_http_errors_direct.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+Direct test for HTTP error handling using the fetch_url tool directly.
+This bypasses potential network connectivity issues by testing the tool's behavior.
+"""
+
+import pytest
+import sys
+import os
+
+# Add the janito package to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "."))
+
+from janito.tools.adapters.local.fetch_url import FetchUrlTool
+
+
+def test_direct_tool_usage():
+    """Test the fetch_url tool directly with mock scenarios."""
+    tool = FetchUrlTool()
+
+    # Test with a clearly invalid domain
+    result = tool.run("https://nonexistent-domain-12345.invalid")
+    print(f"Invalid domain result: {result}")
+
+    # Should contain network error information
+    assert "Network Error" in result or "Failed to connect" in result
+
+    # Test with a well-known accessible URL
+    result = tool.run("https://www.google.com")
+    print(f"Google result: {result[:100]}...")
+
+    # Should contain some content
+    assert len(result) > 0
+
+    # Test with httpstat.us for specific HTTP status codes
+    # Note: This might fail due to network issues, but we want to see the behavior
+    try:
+        result = tool.run("https://httpstat.us/404")
+        print(f"404 test result: {result}")
+        assert "HTTP 404" in result or "404" in result
+    except Exception as e:
+        print(f"404 test failed with exception: {e}")
+        # This is expected if there's no internet connectivity
+
+    # Test timeout handling
+    result = tool.run("https://httpstat.us/200?sleep=10000", timeout=2)
+    print(f"Timeout test result: {result}")
+    assert "Timeout" in result or "Network Error" in result
+
+
+if __name__ == "__main__":
+    test_direct_tool_usage()
+    print("All tests completed!")