xenfra-sdk 0.1.0__tar.gz → 0.1.2__tar.gz

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xenfra-sdk
-Version: 0.1.0
+Version: 0.1.2
 Summary: Xenfra SDK: Core engine and utilities for the Xenfra platform.
 Author: xenfra-cloud
 Author-email: xenfra-cloud <xenfracloud@gmail.com>

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xenfra-sdk"
-version = "0.1.0"
+version = "0.1.2"
 description = "Xenfra SDK: Core engine and utilities for the Xenfra platform."
 readme = "README.md"
 authors = [

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/client.py

@@ -9,7 +9,11 @@ from .resources.projects import ProjectsManager
 
 
 class XenfraClient:
-    def __init__(self, token: str = None, api_url: str = "http://localhost:8000"):
+    def __init__(self, token: str = None, api_url: str = None):
+        # Use provided URL, or fall back to env var, or default to production
+        if api_url is None:
+            api_url = os.getenv("XENFRA_API_URL", "https://api.xenfra.tech")
+
         self.api_url = api_url
         self._token = token or os.getenv("XENFRA_TOKEN")
         if not self._token:
@@ -42,7 +46,21 @@ class XenfraClient:
             return response
         except httpx.HTTPStatusError as e:
             # Convert httpx error to our custom SDK error
-            detail = e.response.json().get("detail", e.response.text)
+            # Safe JSON parsing with fallback
+            try:
+                content_type = e.response.headers.get("content-type", "")
+                if "application/json" in content_type:
+                    try:
+                        error_data = e.response.json()
+                        detail = error_data.get(
+                            "detail", e.response.text[:500] if e.response.text else "Unknown error"
+                        )
+                    except (ValueError, TypeError):
+                        detail = e.response.text[:500] if e.response.text else "Unknown error"
+                else:
+                    detail = e.response.text[:500] if e.response.text else "Unknown error"
+            except Exception:
+                detail = "Unknown error"
             raise XenfraAPIError(status_code=e.response.status_code, detail=detail) from e
         except httpx.RequestError as e:
             # Handle connection errors, timeouts, etc.
@@ -65,5 +83,5 @@ class XenfraClient:
 
     def __del__(self):
         """Destructor - cleanup if not already closed."""
-        if hasattr(self, '_closed') and not self._closed:
+        if hasattr(self, "_closed") and not self._closed:
             self.close()

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/client_with_hooks.py

@@ -1,9 +1,10 @@
 """
 Enhanced XenfraClient with context management and lifecycle hooks.
 """
+
 import logging
 import os
-from typing import Any, Callable, Optional
+from typing import Callable
 
 import httpx
 
@@ -102,7 +103,7 @@ class XenfraClient:
             headers={
                 "Authorization": f"Bearer {self._token}",
                 "Content-Type": "application/json",
-                "User-Agent": "Xenfra-SDK/0.2.0",
+                "User-Agent": "Xenfra-SDK/0.2.4",
             },
             timeout=timeout,
             transport=transport,
@@ -178,7 +179,25 @@ class XenfraClient:
 
         except httpx.HTTPStatusError as e:
             # API error (4xx, 5xx)
-            detail = e.response.json().get("detail", e.response.text) if e.response else str(e)
+            # Safe JSON parsing with fallback
+            if e.response:
+                try:
+                    content_type = e.response.headers.get("content-type", "")
+                    if "application/json" in content_type:
+                        try:
+                            error_data = e.response.json()
+                            detail = error_data.get(
+                                "detail",
+                                e.response.text[:500] if e.response.text else "Unknown error",
+                            )
+                        except (ValueError, TypeError):
+                            detail = e.response.text[:500] if e.response.text else "Unknown error"
+                    else:
+                        detail = e.response.text[:500] if e.response.text else "Unknown error"
+                except Exception:
+                    detail = "Unknown error"
+            else:
+                detail = str(e)
 
             # Run error hooks
             error_context = {**request_context, "error": e, "response": e.response}
@@ -189,11 +208,12 @@ class XenfraClient:
                     logger.warning(f"on_error hook failed: {hook_error}")
 
             # Log error
-            logger.error(f"{method} {path} failed: {e.response.status_code if e.response else 'unknown'}")
+            logger.error(
+                f"{method} {path} failed: {e.response.status_code if e.response else 'unknown'}"
+            )
 
             raise XenfraAPIError(
-                status_code=e.response.status_code if e.response else 500,
-                detail=detail
+                status_code=e.response.status_code if e.response else 500, detail=detail
             ) from e
 
         except httpx.RequestError as e:
@@ -227,7 +247,9 @@ class XenfraClient:
     def __del__(self):
         """Destructor - cleanup if not already closed."""
         if not self._closed:
-            logger.warning("XenfraClient was not properly closed. Use 'with' statement or call close().")
+            logger.warning(
+                "XenfraClient was not properly closed. Use 'with' statement or call close()."
+            )
             self.close()
 
     def __repr__(self):
@@ -238,6 +260,7 @@ class XenfraClient:
 
 # Example hooks for common use cases
 
+
 def logging_hook_before(request_context):
     """Example: Log all requests."""
     print(f"→ {request_context['method']} {request_context['url']}")
@@ -264,12 +287,14 @@ def rate_limit_tracker_hook(request_context, response):
 def request_timing_hook(request_context):
     """Example: Track request timing."""
     import time
+
     request_context["start_time"] = time.time()
 
 
 def response_timing_hook(request_context, response):
     """Example: Calculate request duration."""
     import time
+
     if "start_time" in request_context:
         duration = time.time() - request_context["start_time"]
         print(f"Request took {duration:.3f}s")

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/config.py

@@ -10,8 +10,8 @@ class Settings(BaseSettings):
     SECRET_KEY: str
     ENCRYPTION_KEY: str
 
-    GITHUB_CLIENT_ID: str
-    GITHUB_CLIENT_SECRET: str
+    GH_CLIENT_ID: str
+    GH_CLIENT_SECRET: str
     GITHUB_REDIRECT_URI: str
     GITHUB_WEBHOOK_SECRET: str
 

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/db/models.py

@@ -15,6 +15,7 @@ class Project(SQLModel, table=True):
     In a microservices architecture, we store the ID but don't enforce
     a foreign key constraint across service boundaries.
     """
+
     id: Optional[int] = Field(default=None, primary_key=True)
     droplet_id: int = Field(unique=True, index=True)
     name: str

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/dependencies.py

@@ -3,6 +3,7 @@
 from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
 from sqlmodel import Session, select
+
 from xenfra.db.models import User
 from xenfra.db.session import get_session
 from xenfra.security import decode_token

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/models.py

@@ -119,12 +119,15 @@ class ProjectRead(BaseModel):
 
 # Intelligence Service Models
 
+
 class PatchObject(BaseModel):
     """
     Represents a structured patch for a configuration file.
     """
 
-    file: str | None = Field(None, description="The name of the file to be patched (e.g., 'requirements.txt')")
+    file: str | None = Field(
+        None, description="The name of the file to be patched (e.g., 'requirements.txt')"
+    )
     operation: str | None = Field(None, description="The patch operation (e.g., 'add', 'replace')")
     path: str | None = Field(None, description="A JSON-like path to the field to be changed")
     value: str | None = Field(None, description="The new value to apply")
@@ -160,11 +163,20 @@ class CodebaseAnalysisResponse(BaseModel):
     cache: str | None = Field(None, description="Detected cache (redis, memcached, none)")
     workers: list[str] | None = Field(None, description="Detected background workers (celery, rq)")
     env_vars: list[str] | None = Field(None, description="Required environment variables")
-    package_manager: str = Field(..., description="Detected package manager (uv, pip, poetry, npm, pnpm, yarn, go, bundler)")
-    dependency_file: str = Field(..., description="Dependency manifest file (pyproject.toml, requirements.txt, package.json, go.mod, Gemfile)")
+    package_manager: str = Field(
+        ..., description="Detected package manager (uv, pip, poetry, npm, pnpm, yarn, go, bundler)"
+    )
+    dependency_file: str = Field(
+        ...,
+        description="Dependency manifest file (pyproject.toml, requirements.txt, package.json, go.mod, Gemfile)",
+    )
     has_conflict: bool = Field(False, description="True if multiple package managers detected")
-    detected_package_managers: list[PackageManagerOption] | None = Field(None, description="All detected package managers (if conflict)")
-    instance_size: str = Field(..., description="Recommended instance size (basic, standard, premium)")
+    detected_package_managers: list[PackageManagerOption] | None = Field(
+        None, description="All detected package managers (if conflict)"
+    )
+    instance_size: str = Field(
+        ..., description="Recommended instance size (basic, standard, premium)"
+    )
     estimated_cost_monthly: float = Field(..., description="Estimated monthly cost in USD")
     confidence: float = Field(..., description="Confidence score (0.0-1.0)")
     notes: str | None = Field(None, description="Additional observations")

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/privacy.py

@@ -5,12 +5,16 @@ 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]"
@@ -20,8 +24,8 @@ _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():
-        print(
-            f"Warning: Patterns file not found at {file_path}. No patterns will be used for scrubbing."
+        logger.warning(
+            f"Patterns file not found at {file_path}. No patterns will be used for scrubbing."
         )
         return []
     try:
@@ -29,7 +33,7 @@ def _load_patterns_from_file(file_path: Path) -> List[str]:
             config = json.load(f)
         return config.get("redaction_patterns", [])
     except json.JSONDecodeError as e:
-        print(f"Error decoding patterns.json: {e}. Falling back to empty patterns.")
+        logger.error(f"Error decoding patterns.json: {e}. Falling back to empty patterns.")
         return []
 
 
@@ -38,16 +42,47 @@ async def _refresh_patterns_from_url(url: str) -> Optional[List[str]]:
     Fetches updated patterns from a URL asynchronously.
     """
     try:
-        async with httpx.AsyncClient() as client:
-            response = await client.get(url, timeout=5.0)
+        # 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()
-            config = response.json()
+
+            # 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:
-        print(f"Error fetching patterns from {url}: {e}")
+        logger.warning(f"Error fetching patterns from {url}: {e}")
         return None
     except json.JSONDecodeError as e:
-        print(f"Error decoding JSON from patterns URL {url}: {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
 
 

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/resources/deployments.py

@@ -3,6 +3,7 @@ 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__)
@@ -19,9 +20,8 @@ class DeploymentsManager(BaseManager):
                 "framework": framework,
             }
             response = self._client._request("POST", "/deployments", json=payload)
-            response.raise_for_status()
-            # Assuming the API returns a dict, which will be parsed into a Deployment model
-            return response.json()
+            # Safe JSON parsing
+            return safe_json_parse(response)
         except XenfraAPIError:
             raise
         except Exception as e:
@@ -42,9 +42,11 @@ class DeploymentsManager(BaseManager):
         """
         try:
             response = self._client._request("GET", f"/deployments/{deployment_id}/status")
-            logger.debug(f"DeploymentsManager.get_status({deployment_id}) response: {response.status_code}")
-            response.raise_for_status()
-            return response.json()
+            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:
@@ -65,12 +67,16 @@ class DeploymentsManager(BaseManager):
         """
         try:
             response = self._client._request("GET", f"/deployments/{deployment_id}/logs")
-            logger.debug(f"DeploymentsManager.get_logs({deployment_id}) response: {response.status_code}")
-            response.raise_for_status()
+            logger.debug(
+                f"DeploymentsManager.get_logs({deployment_id}) response: {response.status_code}"
+            )
 
-            # Parse response - API should return {"logs": "log content"}
-            data = response.json()
-            logs = data.get("logs", "")
+            # 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}")

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/resources/intelligence.py

@@ -2,10 +2,12 @@
 Intelligence resource manager for Xenfra SDK.
 Provides AI-powered deployment diagnosis and codebase analysis.
 """
+
 import logging
 
 from ..exceptions import XenfraAPIError, XenfraError
 from ..models import CodebaseAnalysisResponse, DiagnosisResponse
+from ..utils import safe_json_parse
 from .base import BaseManager
 
 logger = logging.getLogger(__name__)
@@ -21,10 +23,7 @@ class IntelligenceManager(BaseManager):
     """
 
     def diagnose(
-        self,
-        logs: str,
-        package_manager: str | None = None,
-        dependency_file: str | None = None
+        self, logs: str, package_manager: str | None = None, dependency_file: str | None = None
     ) -> DiagnosisResponse:
         """
         Diagnose deployment failure from logs using AI.
@@ -51,18 +50,13 @@ class IntelligenceManager(BaseManager):
             if dependency_file:
                 payload["dependency_file"] = dependency_file
 
-            response = self._client._request(
-                "POST",
-                "/intelligence/diagnose",
-                json=payload
-            )
+            response = self._client._request("POST", "/intelligence/diagnose", json=payload)
 
-            logger.debug(
-                f"IntelligenceManager.diagnose response: status={response.status_code}"
-            )
+            logger.debug(f"IntelligenceManager.diagnose response: status={response.status_code}")
 
-            response.raise_for_status()
-            return DiagnosisResponse(**response.json())
+            # Safe JSON parsing
+            data = safe_json_parse(response)
+            return DiagnosisResponse(**data)
         except XenfraAPIError:
             raise
         except Exception as e:
@@ -85,17 +79,16 @@ class IntelligenceManager(BaseManager):
         """
         try:
             response = self._client._request(
-                "POST",
-                "/intelligence/analyze-codebase",
-                json={"code_snippets": code_snippets}
+                "POST", "/intelligence/analyze-codebase", json={"code_snippets": code_snippets}
             )
 
             logger.debug(
                 f"IntelligenceManager.analyze_codebase response: status={response.status_code}"
             )
 
-            response.raise_for_status()
-            return CodebaseAnalysisResponse(**response.json())
+            # Safe JSON parsing
+            data = safe_json_parse(response)
+            return CodebaseAnalysisResponse(**data)
         except XenfraAPIError:
             raise
         except Exception as e:

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/resources/projects.py

@@ -2,6 +2,7 @@ import logging
 
 from ..exceptions import XenfraAPIError, XenfraError  # Add XenfraError
 from ..models import ProjectRead
+from ..utils import safe_get_json_field, safe_json_parse
 from .base import BaseManager
 
 logger = logging.getLogger(__name__)
@@ -18,8 +19,16 @@ class ProjectsManager(BaseManager):
                 f"body={response.text[:200]}..."  # Truncate long responses
             )
 
-            response.raise_for_status()
-            return [ProjectRead(**p) for p in response.json()["projects"]]
+            # Safe JSON parsing with structure validation
+            data = safe_json_parse(response)
+            projects = safe_get_json_field(data, "projects", [])
+
+            if not isinstance(projects, list):
+                raise XenfraError(
+                    f"Expected 'projects' to be a list, got {type(projects).__name__}"
+                )
+
+            return [ProjectRead(**p) for p in projects]
         except XenfraAPIError:
             raise  # Re-raise API errors
         except Exception as e:
@@ -42,18 +51,16 @@ class ProjectsManager(BaseManager):
         try:
             response = self._client._request("GET", f"/projects/{project_id}")
             logger.debug(f"ProjectsManager.show({project_id}) response: {response.status_code}")
-            response.raise_for_status()
-            return ProjectRead(**response.json())
+            # Safe JSON parsing
+            data = safe_json_parse(response)
+            return ProjectRead(**data)
         except XenfraAPIError:
             raise  # Re-raise API errors
         except Exception as e:
             raise XenfraError(f"Failed to get project {project_id}: {e}")
 
     def create(
-        self,
-        name: str,
-        region: str = "nyc3",
-        size_slug: str = "s-1vcpu-1gb"
+        self, name: str, region: str = "nyc3", size_slug: str = "s-1vcpu-1gb"
     ) -> ProjectRead:
         """Create a new project.
 
@@ -70,15 +77,12 @@ class ProjectsManager(BaseManager):
             XenfraError: If there's a network or parsing error.
         """
         try:
-            payload = {
-                "name": name,
-                "region": region,
-                "size_slug": size_slug
-            }
+            payload = {"name": name, "region": region, "size_slug": size_slug}
             logger.debug(f"ProjectsManager.create payload: {payload}")
             response = self._client._request("POST", "/projects/", json=payload)
-            response.raise_for_status()
-            return ProjectRead(**response.json())
+            # Safe JSON parsing
+            data = safe_json_parse(response)
+            return ProjectRead(**data)
         except XenfraAPIError:
             raise
         except Exception as e:
@@ -87,8 +91,8 @@ class ProjectsManager(BaseManager):
     def delete(self, project_id: str) -> None:
         """Deletes a project."""
         try:
-            response = self._client._request("DELETE", f"/projects/{project_id}")
-            response.raise_for_status()
+            # _request() already handles status codes and raises XenfraAPIError for non-2xx
+            self._client._request("DELETE", f"/projects/{project_id}")
         except XenfraAPIError:
             raise
         except Exception as e:

{xenfra_sdk-0.1.0 → xenfra_sdk-0.1.2}/src/xenfra_sdk/utils.py

@@ -1,5 +1,10 @@
 import os
 import tomllib  # Python 3.11+
+from typing import Any, Dict
+
+import httpx
+
+from .exceptions import XenfraError
 
 
 def get_project_context():
@@ -68,3 +73,47 @@ def get_project_context():
         }
 
     return context
+
+
+def safe_json_parse(response: httpx.Response) -> Dict[str, Any]:
+    """
+    Safely parse JSON from HTTP response with content-type validation and error handling.
+
+    Args:
+        response: HTTP response object
+
+    Returns:
+        Parsed JSON dictionary
+
+    Raises:
+        XenfraError: If response is not JSON or parsing fails
+    """
+    content_type = response.headers.get("content-type", "")
+    if "application/json" not in content_type:
+        # Try to get error text for better error messages
+        error_text = response.text[:500] if response.text else "Unknown error"
+        raise XenfraError(f"Expected JSON response, got {content_type}. Response: {error_text}")
+
+    try:
+        return response.json()
+    except (ValueError, TypeError) as e:
+        error_text = response.text[:500] if response.text else "Unknown error"
+        raise XenfraError(f"Failed to parse JSON response: {e}. Response: {error_text}")
+
+
+def safe_get_json_field(data: Dict[str, Any], field: str, default: Any = None) -> Any:
+    """
+    Safely get a field from JSON data with validation.
+
+    Args:
+        data: JSON dictionary
+        field: Field name to retrieve
+        default: Default value if field is missing
+
+    Returns:
+        Field value or default
+    """
+    if not isinstance(data, dict):
+        raise XenfraError(f"Expected dictionary, got {type(data).__name__}")
+
+    return data.get(field, default)