xenfra-sdk 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

xenfra_sdk/privacy.py

@@ -1,151 +1,153 @@
-"""
-This module contains the Privacy Scrubber for the Xenfra SDK.
-Its purpose is to redact sensitive information from logs or other text
-before it is sent to diagnostic endpoints, upholding privacy-first principles.
-"""
-
-import json
-import logging
-import os
-import re
-from pathlib import Path
-from typing import List, Optional
-
-import httpx  # For fetching patterns from URL
-
-logger = logging.getLogger(__name__)
-
-# Path to the patterns file within the SDK
-_PATTERNS_FILE_PATH = Path(__file__).parent / "patterns.json"
-_REDACTION_PLACEHOLDER = "[REDACTED]"
-_CACHED_PATTERNS: List[re.Pattern] = []
-
-
-def _load_patterns_from_file(file_path: Path) -> List[str]:
-    """Loads raw regex patterns from a JSON file."""
-    if not file_path.exists():
-        logger.warning(
-            f"Patterns file not found at {file_path}. No patterns will be used for scrubbing."
-        )
-        return []
-    try:
-        with open(file_path, "r") as f:
-            config = json.load(f)
-        return config.get("redaction_patterns", [])
-    except json.JSONDecodeError as e:
-        logger.error(f"Error decoding patterns.json: {e}. Falling back to empty patterns.")
-        return []
-
-
-async def _refresh_patterns_from_url(url: str) -> Optional[List[str]]:
-    """
-    Fetches updated patterns from a URL asynchronously.
-    """
-    try:
-        # Configure timeout from environment or default to 30 seconds
-        timeout_seconds = float(os.getenv("XENFRA_SDK_TIMEOUT", "30.0"))
-        timeout = httpx.Timeout(timeout_seconds, connect=10.0)
-        
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            response = await client.get(url)
-            response.raise_for_status()
-            
-            # Safe JSON parsing with content-type check
-            content_type = response.headers.get("content-type", "")
-            if "application/json" not in content_type:
-                logger.warning(
-                    f"Expected JSON response from {url}, got {content_type}. "
-                    "Skipping pattern refresh."
-                )
-                return None
-            
-            try:
-                config = response.json()
-            except (ValueError, TypeError) as e:
-                logger.error(f"Failed to parse JSON from patterns URL {url}: {e}")
-                return None
-            
-            if not isinstance(config, dict):
-                logger.error(f"Expected dictionary from patterns URL {url}, got {type(config).__name__}")
-                return None
-            
-            return config.get("redaction_patterns", [])
-    except httpx.TimeoutException as e:
-        logger.warning(f"Timeout fetching patterns from {url}: {e}")
-        return None
-    except httpx.RequestError as e:
-        logger.warning(f"Error fetching patterns from {url}: {e}")
-        return None
-    except json.JSONDecodeError as e:
-        logger.error(f"Error decoding JSON from patterns URL {url}: {e}")
-        return None
-    except Exception as e:
-        logger.error(f"Unexpected error fetching patterns from {url}: {e}")
-        return None
-
-
-async def initialize_scrubber(refresh_from_url: Optional[str] = None):
-    """
-    Initializes or refreshes the scrubber patterns.
-    Can optionally fetch patterns from a URL. This should be called on app startup.
-    """
-    global _CACHED_PATTERNS
-    raw_patterns = []
-
-    if refresh_from_url:
-        refreshed = await _refresh_patterns_from_url(refresh_from_url)
-        if refreshed:
-            raw_patterns = refreshed
-
-    if not raw_patterns:  # Fallback to file if no refresh URL or refresh failed
-        raw_patterns = _load_patterns_from_file(_PATTERNS_FILE_PATH)
-
-    _CACHED_PATTERNS = [re.compile(p, re.IGNORECASE) for p in raw_patterns]
-
-
-# Initialize patterns on module load (synchronously for initial load)
-# For dynamic refresh, initialize_scrubber should be called during app startup
-_raw_initial_patterns = _load_patterns_from_file(_PATTERNS_FILE_PATH)
-_CACHED_PATTERNS = [re.compile(p, re.IGNORECASE) for p in _raw_initial_patterns]
-
-
-def scrub_logs(logs: str) -> str:
-    """
-    Redacts sensitive information from log strings using loaded patterns.
-    """
-    if not logs:
-        return logs
-
-    scrubbed_logs = logs
-    for pattern_re in _CACHED_PATTERNS:
-        scrubbed_logs = pattern_re.sub(_REDACTION_PLACEHOLDER, scrubbed_logs)
-
-    return scrubbed_logs
-
-
-if __name__ == "__main__":
-    # Example Usage
-    test_logs = """
-    Deployment failed. Error: Authentication failed with token dop_v1_abcdefghijklmnopqrstuvwxyz1234567890abcdef.
-    Connecting to database at postgres://user:mypassword@127.0.0.1:5432/mydb.
-    Received request from 192.168.1.100. User: test@example.com.
-    Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
-    eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
-    SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c.
-    AWS Secret: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY.
-    """
-
-    # Test with file-based patterns
-    print("--- Original Logs ---")
-    print(test_logs)
-    print("\n--- Scrubbed Logs (from file) ---")
-    scrubbed_logs_from_file = scrub_logs(test_logs)
-    print(scrubbed_logs_from_file)
-
-    # Example of refreshing (conceptual)
-    # import asyncio
-    # async def demo_refresh():
-    #     await initialize_scrubber(refresh_from_url="http://example.com/new-patterns.json")
-    #     print("\n--- Scrubbed Logs (after conceptual refresh) ---")
-    #     print(scrub_logs(test_logs))
-    # asyncio.run(demo_refresh())
+"""
+This module contains the Privacy Scrubber for the Xenfra SDK.
+Its purpose is to redact sensitive information from logs or other text
+before it is sent to diagnostic endpoints, upholding privacy-first principles.
+"""
+
+import json
+import logging
+import os
+import re
+from pathlib import Path
+from typing import List, Optional
+
+import httpx  # For fetching patterns from URL
+
+logger = logging.getLogger(__name__)
+
+# Path to the patterns file within the SDK
+_PATTERNS_FILE_PATH = Path(__file__).parent / "patterns.json"
+_REDACTION_PLACEHOLDER = "[REDACTED]"
+_CACHED_PATTERNS: List[re.Pattern] = []
+
+
+def _load_patterns_from_file(file_path: Path) -> List[str]:
+    """Loads raw regex patterns from a JSON file."""
+    if not file_path.exists():
+        logger.warning(
+            f"Patterns file not found at {file_path}. No patterns will be used for scrubbing."
+        )
+        return []
+    try:
+        with open(file_path, "r") as f:
+            config = json.load(f)
+        return config.get("redaction_patterns", [])
+    except json.JSONDecodeError as e:
+        logger.error(f"Error decoding patterns.json: {e}. Falling back to empty patterns.")
+        return []
+
+
+async def _refresh_patterns_from_url(url: str) -> Optional[List[str]]:
+    """
+    Fetches updated patterns from a URL asynchronously.
+    """
+    try:
+        # Configure timeout from environment or default to 30 seconds
+        timeout_seconds = float(os.getenv("XENFRA_SDK_TIMEOUT", "30.0"))
+        timeout = httpx.Timeout(timeout_seconds, connect=10.0)
+
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+
+            # Safe JSON parsing with content-type check
+            content_type = response.headers.get("content-type", "")
+            if "application/json" not in content_type:
+                logger.warning(
+                    f"Expected JSON response from {url}, got {content_type}. "
+                    "Skipping pattern refresh."
+                )
+                return None
+
+            try:
+                config = response.json()
+            except (ValueError, TypeError) as e:
+                logger.error(f"Failed to parse JSON from patterns URL {url}: {e}")
+                return None
+
+            if not isinstance(config, dict):
+                logger.error(
+                    f"Expected dictionary from patterns URL {url}, got {type(config).__name__}"
+                )
+                return None
+
+            return config.get("redaction_patterns", [])
+    except httpx.TimeoutException as e:
+        logger.warning(f"Timeout fetching patterns from {url}: {e}")
+        return None
+    except httpx.RequestError as e:
+        logger.warning(f"Error fetching patterns from {url}: {e}")
+        return None
+    except json.JSONDecodeError as e:
+        logger.error(f"Error decoding JSON from patterns URL {url}: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error fetching patterns from {url}: {e}")
+        return None
+
+
+async def initialize_scrubber(refresh_from_url: Optional[str] = None):
+    """
+    Initializes or refreshes the scrubber patterns.
+    Can optionally fetch patterns from a URL. This should be called on app startup.
+    """
+    global _CACHED_PATTERNS
+    raw_patterns = []
+
+    if refresh_from_url:
+        refreshed = await _refresh_patterns_from_url(refresh_from_url)
+        if refreshed:
+            raw_patterns = refreshed
+
+    if not raw_patterns:  # Fallback to file if no refresh URL or refresh failed
+        raw_patterns = _load_patterns_from_file(_PATTERNS_FILE_PATH)
+
+    _CACHED_PATTERNS = [re.compile(p, re.IGNORECASE) for p in raw_patterns]
+
+
+# Initialize patterns on module load (synchronously for initial load)
+# For dynamic refresh, initialize_scrubber should be called during app startup
+_raw_initial_patterns = _load_patterns_from_file(_PATTERNS_FILE_PATH)
+_CACHED_PATTERNS = [re.compile(p, re.IGNORECASE) for p in _raw_initial_patterns]
+
+
+def scrub_logs(logs: str) -> str:
+    """
+    Redacts sensitive information from log strings using loaded patterns.
+    """
+    if not logs:
+        return logs
+
+    scrubbed_logs = logs
+    for pattern_re in _CACHED_PATTERNS:
+        scrubbed_logs = pattern_re.sub(_REDACTION_PLACEHOLDER, scrubbed_logs)
+
+    return scrubbed_logs
+
+
+if __name__ == "__main__":
+    # Example Usage
+    test_logs = """
+    Deployment failed. Error: Authentication failed with token dop_v1_abcdefghijklmnopqrstuvwxyz1234567890abcdef.
+    Connecting to database at postgres://user:mypassword@127.0.0.1:5432/mydb.
+    Received request from 192.168.1.100. User: test@example.com.
+    Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
+    eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
+    SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c.
+    AWS Secret: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY.
+    """
+
+    # Test with file-based patterns
+    print("--- Original Logs ---")
+    print(test_logs)
+    print("\n--- Scrubbed Logs (from file) ---")
+    scrubbed_logs_from_file = scrub_logs(test_logs)
+    print(scrubbed_logs_from_file)
+
+    # Example of refreshing (conceptual)
+    # import asyncio
+    # async def demo_refresh():
+    #     await initialize_scrubber(refresh_from_url="http://example.com/new-patterns.json")
+    #     print("\n--- Scrubbed Logs (after conceptual refresh) ---")
+    #     print(scrub_logs(test_logs))
+    # asyncio.run(demo_refresh())

xenfra_sdk/recipes.py

@@ -1,25 +1,25 @@
-from pathlib import Path
-
-from jinja2 import Environment, FileSystemLoader
-
-
-def generate_stack(context: dict):
-    """
-    Generates a cloud-init startup script from a Jinja2 template.
-
-    Args:
-        context: A dictionary containing information for rendering the template,
-                 e.g., {'domain': 'example.com', 'email': 'user@example.com'}
-    """
-    # Path to the templates directory
-    template_dir = Path(__file__).parent / "templates"
-    env = Environment(loader=FileSystemLoader(template_dir))
-
-    template = env.get_template("cloud-init.sh.j2")
-
-    # The non-dockerized logic has been removed as we are focusing on
-    # a purely Docker-based deployment strategy for simplicity and scalability.
-    # The context will contain all necessary variables for the template.
-    script = template.render(context)
-
-    return script
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader
+
+
+def generate_stack(context: dict):
+    """
+    Generates a cloud-init startup script from a Jinja2 template.
+
+    Args:
+        context: A dictionary containing information for rendering the template,
+                 e.g., {'domain': 'example.com', 'email': 'user@example.com'}
+    """
+    # Path to the templates directory
+    template_dir = Path(__file__).parent / "templates"
+    env = Environment(loader=FileSystemLoader(template_dir))
+
+    template = env.get_template("cloud-init.sh.j2")
+
+    # The non-dockerized logic has been removed as we are focusing on
+    # a purely Docker-based deployment strategy for simplicity and scalability.
+    # The context will contain all necessary variables for the template.
+    script = template.render(context)
+
+    return script

xenfra_sdk/resources/base.py

@@ -1,3 +1,3 @@
-class BaseManager:
-    def __init__(self, client):
-        self._client = client
+class BaseManager:
+    def __init__(self, client):
+        self._client = client

xenfra_sdk/resources/deployments.py

@@ -1,85 +1,89 @@
-import logging
-
-# Import Deployment model when it's defined in models.py
-# from ..models import Deployment
-from ..exceptions import XenfraAPIError, XenfraError  # Add XenfraError
-from ..utils import safe_get_json_field, safe_json_parse
-from .base import BaseManager
-
-logger = logging.getLogger(__name__)
-
-
-class DeploymentsManager(BaseManager):
-    def create(self, project_name: str, git_repo: str, branch: str, framework: str) -> dict:
-        """Creates a new deployment."""
-        try:
-            payload = {
-                "project_name": project_name,
-                "git_repo": git_repo,
-                "branch": branch,
-                "framework": framework,
-            }
-            response = self._client._request("POST", "/deployments", json=payload)
-            # Safe JSON parsing
-            return safe_json_parse(response)
-        except XenfraAPIError:
-            raise
-        except Exception as e:
-            raise XenfraError(f"Failed to create deployment: {e}")
-
-    def get_status(self, deployment_id: str) -> dict:
-        """Get status for a specific deployment.
-
-        Args:
-            deployment_id: The unique identifier for the deployment.
-
-        Returns:
-            dict: Deployment status information including state, progress, etc.
-
-        Raises:
-            XenfraAPIError: If the API returns an error (e.g., 404 not found).
-            XenfraError: If there's a network or parsing error.
-        """
-        try:
-            response = self._client._request("GET", f"/deployments/{deployment_id}/status")
-            logger.debug(f"DeploymentsManager.get_status({deployment_id}) response: {response.status_code}")
-            # Safe JSON parsing - _request() already handles status codes
-            return safe_json_parse(response)
-        except XenfraAPIError:
-            raise  # Re-raise API errors
-        except Exception as e:
-            raise XenfraError(f"Failed to get status for deployment {deployment_id}: {e}")
-
-    def get_logs(self, deployment_id: str) -> str:
-        """Get logs for a specific deployment.
-
-        Args:
-            deployment_id: The unique identifier for the deployment.
-
-        Returns:
-            str: The deployment logs as plain text.
-
-        Raises:
-            XenfraAPIError: If the API returns an error (e.g., 404 not found).
-            XenfraError: If there's a network or parsing error.
-        """
-        try:
-            response = self._client._request("GET", f"/deployments/{deployment_id}/logs")
-            logger.debug(f"DeploymentsManager.get_logs({deployment_id}) response: {response.status_code}")
-
-            # Safe JSON parsing with structure validation - _request() already handles status codes
-            data = safe_json_parse(response)
-            if not isinstance(data, dict):
-                raise XenfraError(f"Expected dictionary response, got {type(data).__name__}")
-            
-            logs = safe_get_json_field(data, "logs", "")
-
-            if not logs:
-                logger.warning(f"No logs found for deployment {deployment_id}")
-
-            return logs
-
-        except XenfraAPIError:
-            raise  # Re-raise API errors
-        except Exception as e:
-            raise XenfraError(f"Failed to get logs for deployment {deployment_id}: {e}")
+import logging
+
+# Import Deployment model when it's defined in models.py
+# from ..models import Deployment
+from ..exceptions import XenfraAPIError, XenfraError  # Add XenfraError
+from ..utils import safe_get_json_field, safe_json_parse
+from .base import BaseManager
+
+logger = logging.getLogger(__name__)
+
+
+class DeploymentsManager(BaseManager):
+    def create(self, project_name: str, git_repo: str, branch: str, framework: str) -> dict:
+        """Creates a new deployment."""
+        try:
+            payload = {
+                "project_name": project_name,
+                "git_repo": git_repo,
+                "branch": branch,
+                "framework": framework,
+            }
+            response = self._client._request("POST", "/deployments", json=payload)
+            # Safe JSON parsing
+            return safe_json_parse(response)
+        except XenfraAPIError:
+            raise
+        except Exception as e:
+            raise XenfraError(f"Failed to create deployment: {e}")
+
+    def get_status(self, deployment_id: str) -> dict:
+        """Get status for a specific deployment.
+
+        Args:
+            deployment_id: The unique identifier for the deployment.
+
+        Returns:
+            dict: Deployment status information including state, progress, etc.
+
+        Raises:
+            XenfraAPIError: If the API returns an error (e.g., 404 not found).
+            XenfraError: If there's a network or parsing error.
+        """
+        try:
+            response = self._client._request("GET", f"/deployments/{deployment_id}/status")
+            logger.debug(
+                f"DeploymentsManager.get_status({deployment_id}) response: {response.status_code}"
+            )
+            # Safe JSON parsing - _request() already handles status codes
+            return safe_json_parse(response)
+        except XenfraAPIError:
+            raise  # Re-raise API errors
+        except Exception as e:
+            raise XenfraError(f"Failed to get status for deployment {deployment_id}: {e}")
+
+    def get_logs(self, deployment_id: str) -> str:
+        """Get logs for a specific deployment.
+
+        Args:
+            deployment_id: The unique identifier for the deployment.
+
+        Returns:
+            str: The deployment logs as plain text.
+
+        Raises:
+            XenfraAPIError: If the API returns an error (e.g., 404 not found).
+            XenfraError: If there's a network or parsing error.
+        """
+        try:
+            response = self._client._request("GET", f"/deployments/{deployment_id}/logs")
+            logger.debug(
+                f"DeploymentsManager.get_logs({deployment_id}) response: {response.status_code}"
+            )
+
+            # Safe JSON parsing with structure validation - _request() already handles status codes
+            data = safe_json_parse(response)
+            if not isinstance(data, dict):
+                raise XenfraError(f"Expected dictionary response, got {type(data).__name__}")
+
+            logs = safe_get_json_field(data, "logs", "")
+
+            if not logs:
+                logger.warning(f"No logs found for deployment {deployment_id}")
+
+            return logs
+
+        except XenfraAPIError:
+            raise  # Re-raise API errors
+        except Exception as e:
+            raise XenfraError(f"Failed to get logs for deployment {deployment_id}: {e}")