clouditia-manager 1.0.0__py3-none-any.whl

clouditia_manager/__init__.py

@@ -0,0 +1,43 @@
+"""
+Clouditia Manager SDK - Manage GPU sessions via the Computing API
+
+Usage:
+    from clouditia_manager import GPUManager
+
+    manager = GPUManager(api_key="sk_compute_...")
+
+    # Create a session
+    session = manager.create_session(
+        gpu_type="nvidia-rtx-3090",
+        vcpu=2,
+        ram=4,
+        storage=20
+    )
+
+    # List sessions
+    sessions = manager.list_sessions()
+
+    # Stop a session
+    manager.stop_session("369bde33")
+"""
+
+__version__ = "1.0.0"
+__author__ = "Clouditia"
+
+from .client import GPUManager
+from .exceptions import (
+    ClouditiaManagerError,
+    AuthenticationError,
+    SessionNotFoundError,
+    InsufficientResourcesError,
+    APIError
+)
+
+__all__ = [
+    "GPUManager",
+    "ClouditiaManagerError",
+    "AuthenticationError",
+    "SessionNotFoundError",
+    "InsufficientResourcesError",
+    "APIError"
+]

clouditia_manager/client.py

@@ -0,0 +1,543 @@
+"""
+Clouditia Manager SDK Client
+
+Manage GPU sessions via the Computing API (sk_compute_ keys)
+"""
+
+import requests
+import time
+import sys
+from typing import Optional, Dict, List, Any, Callable
+from dataclasses import dataclass
+from datetime import datetime
+
+from .exceptions import (
+    ClouditiaManagerError,
+    AuthenticationError,
+    SessionNotFoundError,
+    InsufficientResourcesError,
+    APIError
+)
+
+
+@dataclass
+class GPUSession:
+    """Represents a GPU session"""
+    id: str
+    short_id: str
+    name: str
+    status: str
+    gpu_type: str
+    gpu_count: int
+    vcpu: int
+    ram: str
+    storage: str
+    vscode_port: Optional[int]
+    jupyter_port: Optional[int]
+    password: Optional[str]
+    url: str
+    created_at: Optional[datetime]
+    started_at: Optional[datetime]
+
+    def __repr__(self):
+        return f"GPUSession(name='{self.name}', id='{self.short_id}', status='{self.status}')"
+
+
+@dataclass
+class GPUInventory:
+    """Represents GPU inventory in marketplace"""
+    gpu_type: str
+    gpu_name: str
+    total: int
+    available: int
+    in_use: int
+    price_per_hour: float
+
+    def __repr__(self):
+        return f"GPUInventory(type='{self.gpu_type}', available={self.available}/{self.total})"
+
+
+class GPUManager:
+    """
+    Clouditia GPU Manager Client
+
+    Manage GPU sessions using the Computing API.
+
+    Args:
+        api_key: Your sk_compute_ API key
+        base_url: API base URL (default: https://clouditia.com)
+        timeout: Request timeout in seconds (default: 60)
+    """
+
+    DEFAULT_BASE_URL = "https://clouditia.com"
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = None,
+        timeout: int = 60
+    ):
+        if not api_key or not api_key.startswith("sk_compute_"):
+            raise AuthenticationError("Invalid API key. Must start with 'sk_compute_'")
+
+        self.api_key = api_key
+        self.base_url = (base_url or self.DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "clouditia-manager/1.0.0"
+        })
+
+        # Verify API key on init
+        self._verify_api_key()
+
+    def _verify_api_key(self):
+        """Verify the API key is valid"""
+        try:
+            response = self._request("GET", "/api/computing/verify/")
+            if not response.get("valid"):
+                raise AuthenticationError("API key is not valid")
+            self.user = response.get("user", {})
+        except requests.exceptions.RequestException as e:
+            raise APIError(f"Failed to verify API key: {e}")
+
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Dict = None,
+        params: Dict = None
+    ) -> Dict:
+        """Make an API request"""
+        url = f"{self.base_url}{endpoint}"
+
+        try:
+            response = self._session.request(
+                method=method,
+                url=url,
+                json=data,
+                params=params,
+                timeout=self.timeout
+            )
+
+            if response.status_code == 401:
+                raise AuthenticationError("Invalid or expired API key")
+            elif response.status_code == 403:
+                raise AuthenticationError("Access denied")
+            elif response.status_code == 404:
+                raise SessionNotFoundError("Resource not found")
+
+            response.raise_for_status()
+            return response.json()
+
+        except requests.exceptions.JSONDecodeError:
+            return {"raw": response.text}
+        except requests.exceptions.RequestException as e:
+            raise APIError(f"Request failed: {e}")
+
+    def create_session(
+        self,
+        gpu_type: str = "nvidia-rtx-3090",
+        gpu_count: int = 1,
+        vcpu: int = 4,
+        ram: int = 16,
+        storage: int = 20,
+        wait_ready: bool = True,
+        timeout: int = 180,
+        verbose: bool = True
+    ) -> GPUSession:
+        """
+        Create a new GPU session.
+
+        Args:
+            gpu_type: GPU type slug (e.g., 'nvidia-rtx-3090', 'nvidia-rtx-4090')
+            gpu_count: Number of GPUs (default: 1)
+            vcpu: Number of vCPUs (default: 4)
+            ram: RAM in GB (default: 16)
+            storage: Storage in GB (default: 20)
+            wait_ready: Wait for session to be fully ready (default: True)
+            timeout: Max wait time in seconds (default: 180)
+            verbose: Print status messages (default: True)
+
+        Returns:
+            GPUSession object with session details
+
+        Raises:
+            InsufficientResourcesError: If requested GPU is not available
+            APIError: If session creation fails
+        """
+        data = {
+            "gpu_type": gpu_type,
+            "gpu_count": gpu_count,
+            "vcpu": vcpu,
+            "ram": ram,
+            "storage": storage
+        }
+
+        if verbose:
+            print(f"Creating GPU session with {gpu_type}...")
+
+        response = self._request("POST", "/api/computing/sessions/create/", data=data)
+
+        if not response.get("success"):
+            error = response.get("error", "Unknown error")
+            if "disponible" in error.lower() or "available" in error.lower():
+                raise InsufficientResourcesError(error)
+            raise APIError(error)
+
+        session_data = response.get("session", {})
+        session = self._parse_session(session_data)
+
+        if verbose:
+            print(f"Session created: {session.short_id}")
+
+        # Wait for session to be fully ready
+        if wait_ready:
+            session = self._wait_for_ready(session.short_id, timeout=timeout, verbose=verbose)
+
+        return session
+
+    def _wait_for_ready(
+        self,
+        session_id: str,
+        timeout: int = 180,
+        poll_interval: int = 3,
+        verbose: bool = True
+    ) -> GPUSession:
+        """
+        Internal method: Wait for session and GPU resources to be ready.
+
+        This method polls the session status until it's running and ready.
+        GPU resource updates are handled automatically by the server.
+        """
+        if verbose:
+            print(f"Waiting for session {session_id} to be ready...", end="", flush=True)
+
+        start_time = time.time()
+        last_status = None
+
+        while time.time() - start_time < timeout:
+            try:
+                session = self.get_session(session_id)
+
+                if session.status != last_status:
+                    last_status = session.status
+                    if verbose and session.status == "pending":
+                        print(".", end="", flush=True)
+
+                if session.status == "running":
+                    # Give a moment for GPU resources to fully initialize
+                    time.sleep(2)
+
+                    if verbose:
+                        print(" Ready!")
+                        print(f"\n{'='*50}")
+                        print(f"  SESSION READY")
+                        print(f"{'='*50}")
+                        print(f"  Name     : {session.name}")
+                        print(f"  Short ID : {session.short_id}")
+                        print(f"  Status   : {session.status}")
+                        print(f"  GPU      : {session.gpu_type} x{session.gpu_count}")
+                        print(f"  vCPU     : {session.vcpu}")
+                        print(f"  RAM      : {session.ram}")
+                        print(f"  Storage  : {session.storage}")
+                        print(f"  URL      : {session.url}")
+                        print(f"  Password : {session.password}")
+                        print(f"{'='*50}\n")
+
+                    return session
+
+                elif session.status == "failed":
+                    if verbose:
+                        print(" Failed!")
+                    raise APIError(f"Session {session_id} failed to start")
+
+            except SessionNotFoundError:
+                pass
+
+            if verbose:
+                print(".", end="", flush=True)
+
+            time.sleep(poll_interval)
+
+        if verbose:
+            print(" Timeout!")
+        raise APIError(f"Timeout waiting for session {session_id} to be ready")
+
+    def stop_session(
+        self,
+        session_id: str,
+        wait_stopped: bool = True,
+        timeout: int = 120,
+        verbose: bool = True
+    ) -> GPUSession:
+        """
+        Stop a running GPU session.
+
+        Args:
+            session_id: Session ID (short or full UUID)
+            wait_stopped: Wait for session to be fully stopped (default: True)
+            timeout: Max wait time in seconds (default: 120)
+            verbose: Print status messages (default: True)
+
+        Returns:
+            GPUSession object with final status
+
+        Raises:
+            SessionNotFoundError: If session is not found
+        """
+        # Get session info first
+        try:
+            session = self.get_session(session_id)
+        except SessionNotFoundError:
+            raise SessionNotFoundError(f"Session {session_id} not found")
+
+        if verbose:
+            print(f"Stopping session {session.short_id}...")
+
+        response = self._request(
+            "POST",
+            "/api/computing/sessions/stop/",
+            data={"session_id": session_id}
+        )
+
+        if not response.get("success"):
+            error = response.get("error", "Unknown error")
+            if "not found" in error.lower() or "non trouvée" in error.lower():
+                raise SessionNotFoundError(f"Session {session_id} not found")
+            raise APIError(error)
+
+        # Wait for session to be fully stopped
+        if wait_stopped:
+            session = self._wait_for_stopped(
+                session.short_id,
+                session_info=session,
+                timeout=timeout,
+                verbose=verbose
+            )
+
+        return session
+
+    def _wait_for_stopped(
+        self,
+        session_id: str,
+        session_info: GPUSession = None,
+        timeout: int = 120,
+        poll_interval: int = 2,
+        verbose: bool = True
+    ) -> GPUSession:
+        """
+        Internal method: Wait for session and pods to be fully stopped.
+
+        GPU resource updates are handled automatically by the server.
+        """
+        if verbose:
+            print(f"Waiting for pod termination...", end="", flush=True)
+
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            try:
+                session = self.get_session(session_id)
+
+                if session.status == "stopped":
+                    if verbose:
+                        print(" Done!")
+                        print(f"\n{'='*50}")
+                        print(f"  SESSION STOPPED")
+                        print(f"{'='*50}")
+                        print(f"  Name     : {session.name}")
+                        print(f"  Short ID : {session.short_id}")
+                        print(f"  Status   : {session.status}")
+                        print(f"  GPU      : {session.gpu_type} (released)")
+                        print(f"{'='*50}\n")
+
+                    return session
+
+            except SessionNotFoundError:
+                # Session might be deleted, consider it stopped
+                session_name = session_info.name if session_info else f"compute-gpu-{session_id}"
+                if verbose:
+                    print(" Done!")
+                    print(f"\n{'='*50}")
+                    print(f"  SESSION STOPPED")
+                    print(f"{'='*50}")
+                    print(f"  Name     : {session_name}")
+                    print(f"  Short ID : {session_id}")
+                    print(f"  Status   : stopped (deleted)")
+                    print(f"{'='*50}\n")
+
+                if session_info:
+                    session_info.status = "stopped"
+                    return session_info
+                return None
+
+            if verbose:
+                print(".", end="", flush=True)
+
+            time.sleep(poll_interval)
+
+        if verbose:
+            print(" Timeout!")
+
+        # Return last known state
+        try:
+            return self.get_session(session_id)
+        except:
+            if session_info:
+                return session_info
+            raise APIError(f"Timeout waiting for session {session_id} to stop")
+
+    def get_session(self, session_id: str) -> GPUSession:
+        """
+        Get details of a specific session.
+
+        Args:
+            session_id: Session ID (short or full UUID)
+
+        Returns:
+            GPUSession object
+        """
+        response = self._request(
+            "GET",
+            "/api/computing/sessions/status/",
+            params={"session_id": session_id}
+        )
+
+        if not response.get("success"):
+            raise SessionNotFoundError(f"Session {session_id} not found")
+
+        return self._parse_session(response.get("session", {}))
+
+    def list_sessions(self, status: str = None) -> List[GPUSession]:
+        """
+        List all GPU sessions.
+
+        Args:
+            status: Filter by status ('running', 'stopped', 'pending')
+
+        Returns:
+            List of GPUSession objects
+        """
+        params = {}
+        if status:
+            params["status"] = status
+
+        response = self._request("GET", "/api/computing/sessions/", params=params)
+
+        sessions = []
+        for session_data in response.get("sessions", []):
+            sessions.append(self._parse_session(session_data))
+
+        return sessions
+
+    def get_inventory(self) -> List[GPUInventory]:
+        """
+        Get available GPU inventory.
+
+        Returns:
+            List of GPUInventory objects
+        """
+        response = self._request("GET", "/api/computing/inventory/")
+
+        inventory = []
+        for item in response.get("inventory", []):
+            inventory.append(GPUInventory(
+                gpu_type=item.get("gpu_type", ""),
+                gpu_name=item.get("gpu_name", ""),
+                total=item.get("total", 0),
+                available=item.get("available", 0),
+                in_use=item.get("in_use", 0),
+                price_per_hour=item.get("price_per_hour", 0.0)
+            ))
+
+        return inventory
+
+    def generate_sdk_key(self, session_id: str, name: str = "SDK Key") -> str:
+        """
+        Generate an sk_live_ API key for a session.
+
+        This key can be used with the 'clouditia' SDK to execute code.
+
+        Args:
+            session_id: Session ID
+            name: Key name (default: "SDK Key")
+
+        Returns:
+            The generated sk_live_ API key
+        """
+        response = self._request(
+            "POST",
+            "/api/computing/sessions/generate-key/",
+            data={"session_id": session_id, "name": name}
+        )
+
+        if not response.get("success"):
+            raise APIError(response.get("error", "Failed to generate key"))
+
+        return response.get("api_key")
+
+    def rename_session(self, session_id: str, new_name: str) -> GPUSession:
+        """
+        Rename a GPU session.
+
+        Args:
+            session_id: Session ID (short or full UUID)
+            new_name: New name for the session
+
+        Returns:
+            GPUSession object with updated name
+        """
+        response = self._request(
+            "POST",
+            "/api/computing/sessions/rename/",
+            data={"session_id": session_id, "name": new_name}
+        )
+
+        if not response.get("success"):
+            error = response.get("error", "Failed to rename session")
+            if "not found" in error.lower():
+                raise SessionNotFoundError(f"Session {session_id} not found")
+            raise APIError(error)
+
+        # Get updated session
+        return self.get_session(session_id)
+
+    def _parse_session(self, data: Dict) -> GPUSession:
+        """Parse session data into GPUSession object"""
+        session_id = data.get("id", "")
+        short_id = session_id[:8] if session_id else ""
+        return GPUSession(
+            id=session_id,
+            short_id=short_id,
+            name=data.get("name", f"compute-gpu-{short_id}"),
+            status=data.get("status", "unknown"),
+            gpu_type=data.get("gpu_type", ""),
+            gpu_count=data.get("gpu_count", 1),
+            vcpu=data.get("vcpu", 0),
+            ram=data.get("ram", ""),
+            storage=data.get("storage", ""),
+            vscode_port=data.get("vscode_port"),
+            jupyter_port=data.get("jupyter_port"),
+            password=data.get("password"),
+            url=data.get("url", f"https://clouditia.com/code-editor/{session_id}/"),
+            created_at=self._parse_datetime(data.get("created_at")),
+            started_at=self._parse_datetime(data.get("started_at"))
+        )
+
+    @staticmethod
+    def _parse_datetime(value) -> Optional[datetime]:
+        """Parse datetime string"""
+        if not value:
+            return None
+        if isinstance(value, datetime):
+            return value
+        try:
+            return datetime.fromisoformat(value.replace("Z", "+00:00"))
+        except (ValueError, AttributeError):
+            return None
+
+    def __repr__(self):
+        return f"GPUManager(user='{self.user.get('username', 'unknown')}')"

clouditia_manager/exceptions.py

@@ -0,0 +1,31 @@
+"""
+Exceptions for Clouditia Manager SDK
+"""
+
+
+class ClouditiaManagerError(Exception):
+    """Base exception for Clouditia Manager SDK"""
+    pass
+
+
+class AuthenticationError(ClouditiaManagerError):
+    """Raised when API key is invalid or expired"""
+    pass
+
+
+class SessionNotFoundError(ClouditiaManagerError):
+    """Raised when session is not found"""
+    pass
+
+
+class InsufficientResourcesError(ClouditiaManagerError):
+    """Raised when requested GPU resources are not available"""
+    pass
+
+
+class APIError(ClouditiaManagerError):
+    """Raised when API returns an error"""
+    def __init__(self, message, status_code=None, response=None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response

clouditia_manager-1.0.0.dist-info/METADATA

@@ -0,0 +1,308 @@
+Metadata-Version: 2.4
+Name: clouditia-manager
+Version: 1.0.0
+Summary: Manage GPU sessions on Clouditia platform
+Home-page: https://clouditia.com
+Author: Clouditia
+Author-email: support@clouditia.com
+Project-URL: Documentation, https://clouditia.com/docs/manager-sdk
+Project-URL: Bug Reports, https://github.com/clouditia/clouditia-manager/issues
+Project-URL: Source, https://github.com/clouditia/clouditia-manager
+Keywords: gpu cloud computing ml machine-learning clouditia
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Clouditia Manager SDK
+
+SDK Python pour gérer les sessions GPU sur la plateforme Clouditia via l'API Computing (`sk_compute_`).
+
+## Installation
+
+```bash
+pip install clouditia-manager
+```
+
+## Quick Start
+
+```python
+from clouditia_manager import GPUManager
+
+# Initialiser avec votre clé API sk_compute_
+manager = GPUManager(api_key="sk_compute_xxxxx")
+
+# Créer une session GPU
+# Le SDK attend automatiquement que la session soit prête
+session = manager.create_session(
+    gpu_type="nvidia-rtx-3090",
+    vcpu=2,
+    ram=4,
+    storage=20
+)
+
+# Output:
+# Creating GPU session with nvidia-rtx-3090...
+# Session created: 0e4c713a
+# Waiting for session 0e4c713a to be ready... Ready!
+#
+# ==================================================
+#   SESSION READY
+# ==================================================
+#   Name     : compute-gpu-0e4c713a
+#   Short ID : 0e4c713a
+#   Status   : running
+#   GPU      : nvidia-rtx-3090 x1
+#   vCPU     : 2
+#   RAM      : 4Gi
+#   Storage  : 20Gi
+#   URL      : https://clouditia.com/code-editor/...
+#   Password : xxxxxxxxxxxx
+# ==================================================
+
+print(f"Session prête: {session.name}")
+```
+
+## Configuration
+
+```python
+from clouditia_manager import GPUManager
+
+# Configuration par défaut (production)
+manager = GPUManager(api_key="sk_compute_xxxxx")
+
+# Configuration personnalisée (développement local)
+manager = GPUManager(
+    api_key="sk_compute_xxxxx",
+    base_url="http://127.0.0.1:8000/jobs",  # URL de base de l'API
+    timeout=120  # Timeout en secondes
+)
+```
+
+## Fonctionnalités
+
+### 1. Vérifier la clé API
+
+La vérification est automatique à l'initialisation :
+
+```python
+manager = GPUManager(api_key="sk_compute_xxxxx")
+print(f"Utilisateur: {manager.user['username']}")
+print(f"Email: {manager.user['email']}")
+```
+
+### 2. Créer une session GPU
+
+```python
+# Création standard (attend automatiquement que la session soit prête)
+session = manager.create_session(
+    gpu_type="nvidia-rtx-3090",  # Type de GPU
+    gpu_count=1,                  # Nombre de GPUs
+    vcpu=4,                       # Nombre de vCPUs
+    ram=16,                       # RAM en GB
+    storage=20                    # Stockage en GB
+)
+
+# La session est prête avec un nom automatique: compute-gpu-{short_id}
+print(f"Nom: {session.name}")        # compute-gpu-0e4c713a
+print(f"ID: {session.short_id}")     # 0e4c713a
+print(f"Status: {session.status}")   # running
+print(f"URL: {session.url}")
+print(f"Password: {session.password}")
+
+# Options avancées
+session = manager.create_session(
+    gpu_type="nvidia-rtx-3090",
+    wait_ready=True,     # Attendre que la session soit prête (défaut: True)
+    timeout=180,         # Timeout en secondes (défaut: 180)
+    verbose=True         # Afficher les messages de status (défaut: True)
+)
+
+# Mode silencieux (sans attente ni messages)
+session = manager.create_session(
+    gpu_type="nvidia-rtx-3090",
+    wait_ready=False,    # Ne pas attendre
+    verbose=False        # Pas de messages
+)
+```
+
+### 3. Lister les sessions
+
+```python
+# Toutes les sessions
+sessions = manager.list_sessions()
+
+# Filtrer par status
+running = manager.list_sessions(status="running")
+stopped = manager.list_sessions(status="stopped")
+
+for session in sessions:
+    print(f"{session.name} ({session.short_id}): {session.status} - {session.gpu_type}")
+```
+
+### 4. Obtenir le status d'une session
+
+```python
+# Par short ID (8 caractères)
+session = manager.get_session("0e4c713a")
+
+print(f"Nom: {session.name}")        # compute-gpu-0e4c713a
+print(f"Status: {session.status}")   # running
+print(f"GPU: {session.gpu_type}")    # nvidia-rtx-3090
+print(f"URL: {session.url}")
+```
+
+### 5. Renommer une session
+
+```python
+# Chaque session a un nom par défaut: compute-gpu-{short_id}
+session = manager.create_session(gpu_type="nvidia-rtx-3090")
+print(f"Nom par défaut: {session.name}")  # compute-gpu-0e4c713a
+
+# Renommer la session
+session = manager.rename_session("0e4c713a", "mon-projet-ml-v1")
+print(f"Nouveau nom: {session.name}")  # mon-projet-ml-v1
+```
+
+### 6. Arrêter une session
+
+```python
+# Arrêt standard (attend automatiquement la suppression du pod)
+session = manager.stop_session("0e4c713a")
+
+# Output:
+# Stopping session 0e4c713a...
+# Waiting for pod termination... Done!
+#
+# ==================================================
+#   SESSION STOPPED
+# ==================================================
+#   Name     : mon-projet-ml-v1
+#   Short ID : 0e4c713a
+#   Status   : stopped
+#   GPU      : nvidia-rtx-3090 (released)
+# ==================================================
+
+print(f"Session arrêtée: {session.name}")
+print(f"Status: {session.status}")
+
+# Options avancées
+session = manager.stop_session(
+    "0e4c713a",
+    wait_stopped=True,   # Attendre la suppression complète (défaut: True)
+    timeout=120,         # Timeout en secondes (défaut: 120)
+    verbose=True         # Afficher les messages (défaut: True)
+)
+
+# Mode silencieux
+session = manager.stop_session("0e4c713a", wait_stopped=False, verbose=False)
+```
+
+### 7. Consulter l'inventaire GPU
+
+```python
+inventory = manager.get_inventory()
+
+for gpu in inventory:
+    print(f"{gpu.gpu_name}: {gpu.available}/{gpu.total} disponibles")
+    print(f"  Prix: {gpu.price_per_hour}€/h")
+```
+
+### 8. Générer une clé SDK (sk_live_)
+
+```python
+# Générer une clé pour utiliser le SDK clouditia
+sdk_key = manager.generate_sdk_key("0e4c713a", name="Ma clé SDK")
+print(f"Clé SDK: {sdk_key}")  # sk_live_xxxxx...
+
+# Utiliser avec le SDK clouditia
+from clouditia import GPUSession
+gpu = GPUSession(api_key=sdk_key)
+result = gpu.run("print('Hello GPU!')")
+```
+
+## Types de GPU disponibles
+
+| GPU | Slug |
+|-----|------|
+| NVIDIA RTX 3060 Ti | `nvidia-rtx-3060ti` |
+| NVIDIA RTX 3080 Ti | `nvidia-rtx-3080ti` |
+| NVIDIA RTX 3090 | `nvidia-rtx-3090` |
+| NVIDIA RTX 4090 | `nvidia-rtx-4090` |
+
+## Gestion des erreurs
+
+```python
+from clouditia_manager import (
+    GPUManager,
+    AuthenticationError,
+    SessionNotFoundError,
+    InsufficientResourcesError,
+    APIError
+)
+
+try:
+    manager = GPUManager(api_key="sk_compute_xxxxx")
+    session = manager.create_session(gpu_type="nvidia-rtx-4090")
+except AuthenticationError:
+    print("Clé API invalide")
+except InsufficientResourcesError:
+    print("Aucun GPU disponible")
+except SessionNotFoundError:
+    print("Session non trouvée")
+except APIError as e:
+    print(f"Erreur API: {e}")
+```
+
+## Référence API
+
+| Méthode | Description |
+|---------|-------------|
+| `GPUManager(api_key, base_url, timeout)` | Initialise le SDK |
+| `create_session(gpu_type, gpu_count, vcpu, ram, storage, wait_ready, timeout, verbose)` | Crée une session GPU |
+| `stop_session(session_id, wait_stopped, timeout, verbose)` | Arrête une session |
+| `get_session(session_id)` | Récupère les détails d'une session |
+| `list_sessions(status)` | Liste les sessions (filtre optionnel) |
+| `rename_session(session_id, new_name)` | Renomme une session |
+| `get_inventory()` | Récupère l'inventaire GPU |
+| `generate_sdk_key(session_id, name)` | Génère une clé sk_live_ |
+
+## Attributs GPUSession
+
+| Attribut | Type | Description |
+|----------|------|-------------|
+| `id` | str | UUID complet de la session |
+| `short_id` | str | ID court (8 caractères) |
+| `name` | str | Nom de la session |
+| `status` | str | running, stopped, pending, failed |
+| `gpu_type` | str | Type de GPU |
+| `gpu_count` | int | Nombre de GPUs |
+| `vcpu` | int | Nombre de vCPUs |
+| `ram` | str | RAM allouée |
+| `storage` | str | Stockage alloué |
+| `url` | str | URL d'accès |
+| `password` | str | Mot de passe |
+
+## License
+
+MIT License

clouditia_manager-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+clouditia_manager/__init__.py,sha256=1kv3zDC8klv_X3pPL5JmyMmMu6CjlRCvjJ8naGjd9lo,849
+clouditia_manager/client.py,sha256=Jfh9VHzAWK1LuifPfS_A39lv7jvr00Nef7fYNKHpHxw,17301
+clouditia_manager/exceptions.py,sha256=ysn_iuAkyXDO0b3v-AzQmnpqjKuOoo6tVN8VIvCTTYI,753
+clouditia_manager-1.0.0.dist-info/METADATA,sha256=l-KGFW_qYqVgJQW0kBNKZ6EZJdxh2BAjxDGL45jui_0,8937
+clouditia_manager-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clouditia_manager-1.0.0.dist-info/top_level.txt,sha256=rkZJF7zMHNO17z7JYEKk20GrJ30bSNKetDOESvwkA-k,18
+clouditia_manager-1.0.0.dist-info/RECORD,,

clouditia_manager-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

clouditia_manager-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+clouditia_manager