xenfra-sdk 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

xenfra_sdk/client.py

@@ -1,90 +1,90 @@
-import os
-
-import httpx
-
-from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
-from .resources.deployments import DeploymentsManager
-from .resources.files import FilesManager
-from .resources.intelligence import IntelligenceManager
-from .resources.projects import ProjectsManager
-
-
-class XenfraClient:
-    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:
-            raise AuthenticationError(
-                "No API token provided. Pass it to the client or set XENFRA_TOKEN."
-            )
-
-        self._http_client = httpx.Client(
-            base_url=self.api_url,
-            headers={"Authorization": f"Bearer {self._token}", "Content-Type": "application/json"},
-            timeout=30.0,  # Add a reasonable timeout
-        )
-
-        # Track if client is closed
-        self._closed = False
-
-        # Initialize resource managers
-        self.projects = ProjectsManager(self)
-        self.deployments = DeploymentsManager(self)
-        self.intelligence = IntelligenceManager(self)
-        self.files = FilesManager(self)
-
-
-    def _request(self, method: str, path: str, json: dict = None) -> httpx.Response:
-        """Internal method to handle all HTTP requests."""
-        if self._closed:
-            raise XenfraError("Client is closed. Create a new client or use context manager.")
-
-        try:
-            response = self._http_client.request(method, path, json=json)
-            response.raise_for_status()  # Raise HTTPStatusError for 4xx/5xx
-            return response
-        except httpx.HTTPStatusError as e:
-            # Convert httpx error to our custom SDK error
-            # 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.
-            raise XenfraError(f"HTTP request failed: {e}")
-
-    def close(self):
-        """Close the HTTP client and cleanup resources."""
-        if not self._closed:
-            self._http_client.close()
-            self._closed = True
-
-    def __enter__(self):
-        """Context manager entry - allows 'with XenfraClient() as client:' usage."""
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit - ensures cleanup."""
-        self.close()
-        return False  # Don't suppress exceptions
-
-    def __del__(self):
-        """Destructor - cleanup if not already closed."""
-        if hasattr(self, "_closed") and not self._closed:
-            self.close()
+import os
+
+import httpx
+
+from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
+from .resources.deployments import DeploymentsManager
+from .resources.files import FilesManager
+from .resources.intelligence import IntelligenceManager
+from .resources.projects import ProjectsManager
+
+
+class XenfraClient:
+    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:
+            raise AuthenticationError(
+                "No API token provided. Pass it to the client or set XENFRA_TOKEN."
+            )
+
+        self._http_client = httpx.Client(
+            base_url=self.api_url,
+            headers={"Authorization": f"Bearer {self._token}", "Content-Type": "application/json"},
+            timeout=30.0,  # Add a reasonable timeout
+        )
+
+        # Track if client is closed
+        self._closed = False
+
+        # Initialize resource managers
+        self.projects = ProjectsManager(self)
+        self.deployments = DeploymentsManager(self)
+        self.intelligence = IntelligenceManager(self)
+        self.files = FilesManager(self)
+
+
+    def _request(self, method: str, path: str, json: dict = None) -> httpx.Response:
+        """Internal method to handle all HTTP requests."""
+        if self._closed:
+            raise XenfraError("Client is closed. Create a new client or use context manager.")
+
+        try:
+            response = self._http_client.request(method, path, json=json)
+            response.raise_for_status()  # Raise HTTPStatusError for 4xx/5xx
+            return response
+        except httpx.HTTPStatusError as e:
+            # Convert httpx error to our custom SDK error
+            # 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.
+            raise XenfraError(f"HTTP request failed: {e}")
+
+    def close(self):
+        """Close the HTTP client and cleanup resources."""
+        if not self._closed:
+            self._http_client.close()
+            self._closed = True
+
+    def __enter__(self):
+        """Context manager entry - allows 'with XenfraClient() as client:' usage."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - ensures cleanup."""
+        self.close()
+        return False  # Don't suppress exceptions
+
+    def __del__(self):
+        """Destructor - cleanup if not already closed."""
+        if hasattr(self, "_closed") and not self._closed:
+            self.close()

xenfra_sdk/config.py

@@ -1,26 +1,26 @@
-# src/xenfra/config.py
-
-
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class Settings(BaseSettings):
-    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
-
-    SECRET_KEY: str
-    ENCRYPTION_KEY: str
-
-    GH_CLIENT_ID: str
-    GH_CLIENT_SECRET: str
-    GITHUB_REDIRECT_URI: str
-    GITHUB_WEBHOOK_SECRET: str
-
-    DO_CLIENT_ID: str
-    DO_CLIENT_SECRET: str
-    DO_REDIRECT_URI: str
-
-    # Frontend redirect for successful OAuth (e.g., /dashboard/connections)
-    FRONTEND_OAUTH_REDIRECT_SUCCESS: str = "/dashboard/connections"
-
-
-settings = Settings()
+# src/xenfra/config.py
+
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    SECRET_KEY: str
+    ENCRYPTION_KEY: str
+
+    GH_CLIENT_ID: str
+    GH_CLIENT_SECRET: str
+    GITHUB_REDIRECT_URI: str
+    GITHUB_WEBHOOK_SECRET: str
+
+    DO_CLIENT_ID: str
+    DO_CLIENT_SECRET: str
+    DO_REDIRECT_URI: str
+
+    # Frontend redirect for successful OAuth (e.g., /dashboard/connections)
+    FRONTEND_OAUTH_REDIRECT_SUCCESS: str = "/dashboard/connections"
+
+
+settings = Settings()

xenfra_sdk/db/models.py

@@ -1,24 +1,24 @@
-# src/xenfra/db/models.py
-
-from typing import Optional
-
-from sqlmodel import Field, SQLModel
-
-# --- Project Model for CLI state ---
-
-
-class Project(SQLModel, table=True):
-    """
-    Project model storing deployment state in the SDK's local database.
-    """
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    droplet_id: int = Field(unique=True, index=True)
-    name: str
-    ip_address: str
-    status: str
-    region: str
-    size: str
-    # user_id is a reference to User.id in the SSO service database
-    # No foreign key constraint since databases are separate in microservices architecture
-    user_id: int = Field(index=True)  # Index for query performance
+# src/xenfra/db/models.py
+
+from typing import Optional
+
+from sqlmodel import Field, SQLModel
+
+# --- Project Model for CLI state ---
+
+
+class Project(SQLModel, table=True):
+    """
+    Project model storing deployment state in the SDK's local database.
+    """
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    droplet_id: int = Field(unique=True, index=True)
+    name: str
+    ip_address: str
+    status: str
+    region: str
+    size: str
+    # user_id is a reference to User.id in the SSO service database
+    # No foreign key constraint since databases are separate in microservices architecture
+    user_id: int = Field(index=True)  # Index for query performance

xenfra_sdk/db/session.py

@@ -1,30 +1,30 @@
-# src/xenfra/db/session.py
-
-import os
-from pathlib import Path
-
-import click
-from sqlmodel import Session, SQLModel, create_engine
-
-# Get the app directory for the current user
-app_dir = Path(click.get_app_dir("xenfra"))
-app_dir.mkdir(parents=True, exist_ok=True)
-db_path = app_dir / "xenfra.db"
-
-# For now, we will use a simple SQLite database for ease of setup.
-# In production, this should be a PostgreSQL database URL from environment variables.
-DATABASE_URL = os.getenv("DATABASE_URL", f"sqlite:///{db_path}")
-
-# Only echo SQL in development (set SQL_ECHO=1 to enable)
-SQL_ECHO = os.getenv("SQL_ECHO", "0") == "1"
-
-engine = create_engine(DATABASE_URL, echo=SQL_ECHO)
-
-
-def create_db_and_tables():
-    SQLModel.metadata.create_all(engine)
-
-
-def get_session():
-    with Session(engine) as session:
-        yield session
+# src/xenfra/db/session.py
+
+import os
+from pathlib import Path
+
+from sqlmodel import Session, SQLModel, create_engine
+
+# Get the app directory for the current user
+# Use ~/.xenfra for cross-platform simplicity and to avoid 'click' dependency in SDK
+app_dir = Path.home() / ".xenfra"
+app_dir.mkdir(parents=True, exist_ok=True)
+db_path = app_dir / "xenfra.db"
+
+# For now, we will use a simple SQLite database for ease of setup.
+# In production, this should be a PostgreSQL database URL from environment variables.
+DATABASE_URL = os.getenv("DATABASE_URL", f"sqlite:///{db_path}")
+
+# Only echo SQL in development (set SQL_ECHO=1 to enable)
+SQL_ECHO = os.getenv("SQL_ECHO", "0") == "1"
+
+engine = create_engine(DATABASE_URL, echo=SQL_ECHO)
+
+
+def create_db_and_tables():
+    SQLModel.metadata.create_all(engine)
+
+
+def get_session():
+    with Session(engine) as session:
+        yield session

xenfra_sdk/dependencies.py

@@ -1,39 +1,39 @@
-# src/xenfra/dependencies.py
-
-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
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/token")
-
-
-def get_current_user(
-    token: str = Depends(oauth2_scheme), session: Session = Depends(get_session)
-) -> User:
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Could not validate credentials",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-    payload = decode_token(token)
-    if payload is None:
-        raise credentials_exception
-
-    email: str = payload.get("sub")
-    if email is None:
-        raise credentials_exception
-
-    user = session.exec(select(User).where(User.email == email)).first()
-    if user is None:
-        raise credentials_exception
-    return user
-
-
-def get_current_active_user(current_user: User = Depends(get_current_user)) -> User:
-    if not current_user.is_active:
-        raise HTTPException(status_code=400, detail="Inactive user")
-    return current_user
+# src/xenfra/dependencies.py
+
+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
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/token")
+
+
+def get_current_user(
+    token: str = Depends(oauth2_scheme), session: Session = Depends(get_session)
+) -> User:
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    payload = decode_token(token)
+    if payload is None:
+        raise credentials_exception
+
+    email: str = payload.get("sub")
+    if email is None:
+        raise credentials_exception
+
+    user = session.exec(select(User).where(User.email == email)).first()
+    if user is None:
+        raise credentials_exception
+    return user
+
+
+def get_current_active_user(current_user: User = Depends(get_current_user)) -> User:
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user