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

xenfra_sdk/client.py

@@ -6,10 +6,15 @@ from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
 from .resources.deployments import DeploymentsManager
 from .resources.intelligence import IntelligenceManager
 from .resources.projects import ProjectsManager
+from .utils import safe_json_parse
 
 
 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 +47,19 @@ 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.

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
 
@@ -11,6 +12,7 @@ from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
 from .resources.deployments import DeploymentsManager
 from .resources.intelligence import IntelligenceManager
 from .resources.projects import ProjectsManager
+from .utils import safe_json_parse
 
 logger = logging.getLogger(__name__)
 
@@ -102,7 +104,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 +180,22 @@ 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 +206,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 +245,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 +258,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 +285,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/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/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,45 @@ 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/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:
@@ -43,8 +43,8 @@ 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()
+            # Safe JSON parsing - _request() already handles status codes
+            return safe_json_parse(response)
         except XenfraAPIError:
             raise  # Re-raise API errors
         except Exception as e:
@@ -66,11 +66,13 @@ 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()
 
-            # 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/resources/intelligence.py

@@ -6,6 +6,7 @@ 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__)
@@ -61,8 +62,9 @@ class IntelligenceManager(BaseManager):
                 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:
@@ -94,8 +96,9 @@ class IntelligenceManager(BaseManager):
                 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/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,14 @@ 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,8 +49,9 @@ 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:
@@ -77,8 +85,9 @@ class ProjectsManager(BaseManager):
             }
             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 +96,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/utils.py

@@ -1,5 +1,10 @@
 import os
 import tomllib  # Python 3.11+
+from typing import Any, Dict, Optional
+
+import httpx
+
+from .exceptions import XenfraError
 
 
 def get_project_context():
@@ -68,3 +73,49 @@ 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)

{xenfra_sdk-0.1.0.dist-info → xenfra_sdk-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xenfra-sdk
-Version: 0.1.0
+Version: 0.1.1
 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.dist-info → xenfra_sdk-0.1.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 xenfra_sdk/__init__.py,sha256=lk9xo2msYvs_JgBePTIuxRb2sBW-egJS_EAOq4w4xQo,467
 xenfra_sdk/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xenfra_sdk/cli/main.py,sha256=541nlIUYFFeu4h1sCXivaHMC7SqpskazI0YocM8ylh4,7958
-xenfra_sdk/client.py,sha256=vFtfAof8X270-qs6-gD1Qo8LGjpQKxCfwbEe5GWd6nE,2641
-xenfra_sdk/client_with_hooks.py,sha256=ViAWF4lnUml4gjVapTwC7UUQesJn5ZaeGHluZlRC-50,9165
-xenfra_sdk/config.py,sha256=5dlmpxzM9OXJvfhiwG7DsU2XXf1yte4-mISDJdbpzPk,596
+xenfra_sdk/client.py,sha256=pnmdmmTtECyV7MmT2_DViXeaQP0q1W1eOhcqOTdmi80,3495
+xenfra_sdk/client_with_hooks.py,sha256=5mKIF3rbN1hlZKCCNOlMyFBbuwugBeCU9_8ZcQ_8uOs,9986
+xenfra_sdk/config.py,sha256=gaT4k5iJgW9guNVmlnYkCFGDSU1_er4LRZA2CgfKmJ0,588
 xenfra_sdk/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xenfra_sdk/db/models.py,sha256=H29uHzXizkim5KnEAdmfMO8mytkCDCQl2NPzTgMMD7w,874
 xenfra_sdk/db/session.py,sha256=LoTKFO3FTsx5AtZ-0ZsplxXjAdzOgcr3Yk-dkeJsz5U,823
@@ -14,18 +14,18 @@ xenfra_sdk/exceptions.py,sha256=aMVtDVlzG7-FT2G_b-pJSuuey22B4YvC-b-L37GaImM,477
 xenfra_sdk/mcp_client.py,sha256=NZtQz_qK_8i504rVPXlE1vPdzt75hg8Lkp4d8BA8dk0,5777
 xenfra_sdk/models.py,sha256=73rZMHP2iPRcX9PC8KUgkmNEVgDozD4Tj09UneQhYJU,6923
 xenfra_sdk/patterns.json,sha256=xHxbc0ogHDwysMczi30_hW1Ylfdsf-nsQdAom7RZ4KI,446
-xenfra_sdk/privacy.py,sha256=-KmDyFDGmFTg4vS68qtVnDgXxbl9xJmKwPKDG1zPaFU,4176
+xenfra_sdk/privacy.py,sha256=XXNLCrPZzqbYj8qrcootygE2WiDYyMVdMO7h0ow7vBQ,5527
 xenfra_sdk/recipes.py,sha256=J6-7tDWVXv8IelkdBta5pDRhD0o5VgAM_jWDKvPvm5g,852
 xenfra_sdk/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xenfra_sdk/resources/base.py,sha256=5n-HTKAnIX2lTgXwio0xtwoaBn-nksjdm8qRTpe3iDk,81
-xenfra_sdk/resources/deployments.py,sha256=qE9hPW0skt7w6QaqalVGaBAIFu6z4M97crvEn0xzMG4,3116
-xenfra_sdk/resources/intelligence.py,sha256=8W_XjOJSLH9qFNBepc6jgS9wer0NuML4BG8DU6LfXjY,3382
-xenfra_sdk/resources/projects.py,sha256=PNhLhu3-8jR1ucSGtKDRH5fvpNb1IQSzUNXEcojhmHY,3350
+xenfra_sdk/resources/deployments.py,sha256=ybIV4ViNhnjWRkPaynp0wQjEKBjKby0GkAPd3_ohu-w,3291
+xenfra_sdk/resources/intelligence.py,sha256=W1J2tr4W3xKB1v8Wya0edXB07Vr3zO0JZ7mIDk_dU1w,3470
+xenfra_sdk/resources/projects.py,sha256=ZMox7siqSXWuXHsUBYkUb10Qik7wNvgPBZWN3C4gQnA,3760
 xenfra_sdk/security.py,sha256=6vMZpbglhkRGBVVj4RCTu45-MCnQ15wt94-996zmaT8,1199
 xenfra_sdk/templates/Dockerfile.j2,sha256=apWts895OOoUYwj_fOa6OiylFB5m8zFEYvJ1Nki32YM,664
 xenfra_sdk/templates/cloud-init.sh.j2,sha256=QCWG8hL1V05bAQ7BQ70QfuhIvS4tnsL8ZTCVtyi9F0A,2222
 xenfra_sdk/templates/docker-compose.yml.j2,sha256=zKUT2cd_FrxXvRxE-vAAjuQk3-nLNQjRe-StkhAWRQA,860
-xenfra_sdk/utils.py,sha256=J2q2ZATQxgrtoJXrbDCPRNyD7PFuv7ZAybcE99O2cCc,2400
-xenfra_sdk-0.1.0.dist-info/WHEEL,sha256=ZyFSCYkV2BrxH6-HRVRg3R9Fo7MALzer9KiPYqNxSbo,79
-xenfra_sdk-0.1.0.dist-info/METADATA,sha256=UiaTkJ03P59x9D4MT-ONOk1rx3uhojR1VJ914kiRACQ,3889
-xenfra_sdk-0.1.0.dist-info/RECORD,,
+xenfra_sdk/utils.py,sha256=uLlDb-kNRlr6RJvU8vJ6vXfgUEZeWZDfN2UtlrQoxfs,3930
+xenfra_sdk-0.1.1.dist-info/WHEEL,sha256=ZyFSCYkV2BrxH6-HRVRg3R9Fo7MALzer9KiPYqNxSbo,79
+xenfra_sdk-0.1.1.dist-info/METADATA,sha256=jg_JTeKLR_SzyMovzvjYub641lc3nSObkPy7-V9GEe0,3889
+xenfra_sdk-0.1.1.dist-info/RECORD,,