flow-compute 2.0.0__py3-none-any.whl

flow/__init__.py

@@ -0,0 +1,68 @@
+"""Flow SDK - GPU compute made simple."""
+
+# Public API imports
+from flow.api.client import Flow
+from flow.api.decorators import FlowApp, app
+from flow.api.invoke import invoke
+from flow.api.models import Task, TaskConfig, TaskStatus, Volume, VolumeSpec
+
+# Public errors and constants
+from flow.errors import (
+    APIError,
+    AuthenticationError,
+    ConfigParserError,
+    FlowError,
+    FlowOperationError,
+    NetworkError,
+    ProviderError,
+    QuotaExceededError,
+    ResourceNotAvailableError,
+    ResourceNotFoundError,
+    TaskExecutionError,
+    TaskNotFoundError,
+    TimeoutError,
+    ValidationAPIError,
+    ValidationError,
+    VolumeError,
+)
+from flow.providers.fcp.core.constants import DEFAULT_REGION
+
+# Version
+try:
+    from importlib.metadata import version
+    __version__ = version("flow-sdk")
+except Exception:
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    # Main API
+    "Flow",
+    "FlowApp",
+    "invoke",
+    "app",
+    # Models
+    "TaskConfig",
+    "Task",
+    "Volume",
+    "VolumeSpec",
+    "TaskStatus",
+    # Errors
+    "FlowError",
+    "AuthenticationError",
+    "ResourceNotFoundError",
+    "TaskNotFoundError",
+    "ValidationError",
+    "APIError",
+    "ValidationAPIError",
+    "NetworkError",
+    "TimeoutError",
+    "ProviderError",
+    "ConfigParserError",
+    "ResourceNotAvailableError",
+    "QuotaExceededError",
+    "VolumeError",
+    "TaskExecutionError",
+    "FlowOperationError",
+    # Constants
+    "DEFAULT_REGION",
+]

flow/_internal/auth.py

@@ -0,0 +1,333 @@
+"""Authentication support for Flow SDK.
+
+Supports multiple authentication methods:
+- API key authentication (default)
+- Email/password authentication with session management
+"""
+
+import json
+import logging
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from flow.core.interfaces import IHttpClient
+from flow.errors import AuthenticationError
+
+logger = logging.getLogger(__name__)
+
+
+class AuthConfig:
+    """Authentication configuration."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        email: Optional[str] = None,
+        password: Optional[str] = None,
+        session_file: Optional[Path] = None,
+    ):
+        """Initialize auth config.
+
+        Args:
+            api_key: API key for authentication
+            email: Email for email/password auth
+            password: Password for email/password auth
+            session_file: Path to store session data
+        """
+        self.api_key = api_key or os.getenv("FCP_API_KEY")
+        self.email = email
+        self.password = password
+        self.session_file = session_file or self._default_session_file()
+
+    def _default_session_file(self) -> Path:
+        """Get default session file path."""
+        home = Path.home()
+        flow_dir = home / ".flow"
+        flow_dir.mkdir(exist_ok=True)
+        return flow_dir / "session.json"
+
+    @property
+    def has_api_key(self) -> bool:
+        """Check if API key is available."""
+        return bool(self.api_key)
+
+    @property
+    def has_credentials(self) -> bool:
+        """Check if email/password credentials are available."""
+        return bool(self.email and self.password)
+
+
+class Session:
+    """Authentication session data."""
+
+    def __init__(self, token: str, expires_at: datetime, user_id: str):
+        """Initialize session.
+
+        Args:
+            token: Session token
+            expires_at: When session expires
+            user_id: ID of authenticated user
+        """
+        self.token = token
+        self.expires_at = expires_at
+        self.user_id = user_id
+
+    @property
+    def is_valid(self) -> bool:
+        """Check if session is still valid."""
+        return datetime.now() < self.expires_at
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "token": self.token,
+            "expires_at": self.expires_at.isoformat(),
+            "user_id": self.user_id,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Session":
+        """Create from dictionary."""
+        return cls(
+            token=data["token"],
+            expires_at=datetime.fromisoformat(data["expires_at"]),
+            user_id=data["user_id"],
+        )
+
+
+class Authenticator:
+    """Handles authentication for Flow SDK."""
+
+    def __init__(self, config: AuthConfig, http_client: IHttpClient):
+        """Initialize authenticator.
+
+        Args:
+            config: Authentication configuration
+            http_client: HTTP client for API requests
+        """
+        self.config = config
+        self.http = http_client
+        self._session: Optional[Session] = None
+
+    def authenticate(self) -> str:
+        """Get authentication token.
+
+        Returns API key or session token based on configuration.
+
+        Returns:
+            Authentication token
+
+        Raises:
+            AuthenticationError: If authentication fails
+        """
+        # Try API key first
+        if self.config.has_api_key:
+            return self.config.api_key
+
+        # Try existing session
+        if self._session and self._session.is_valid:
+            return self._session.token
+
+        # Try loading saved session
+        saved_session = self._load_session()
+        if saved_session and saved_session.is_valid:
+            self._session = saved_session
+            return saved_session.token
+
+        # Try email/password authentication
+        if self.config.has_credentials:
+            session = self._authenticate_with_credentials()
+            self._session = session
+            self._save_session(session)
+            return session.token
+
+        raise AuthenticationError(
+            "No valid authentication method available. "
+            "Set FCP_API_KEY or provide email/password."
+        )
+
+    def get_access_token(self) -> str:
+        """Get access token for API requests.
+
+        This is a convenience method that wraps authenticate()
+        for compatibility with existing code.
+
+        Returns:
+            Authentication token
+
+        Raises:
+            AuthenticationError: If authentication fails
+        """
+        return self.authenticate()
+
+    def _authenticate_with_credentials(self) -> Session:
+        """Authenticate with email/password.
+
+        Returns:
+            Session object
+
+        Raises:
+            AuthenticationError: If authentication fails
+        """
+        try:
+            response = self.http.request(
+                method="POST",
+                url="/auth/login",
+                json={
+                    "email": self.config.email,
+                    "password": self.config.password,
+                },
+                retry_server_errors=False,  # Don't retry auth failures
+            )
+
+            # Extract session data
+            token = response.get("token")
+            expires_in = response.get("expires_in", 3600)  # Default 1 hour
+            user_id = response.get("user_id", "")
+
+            if not token:
+                raise AuthenticationError("No token in login response")
+
+            # Create session
+            expires_at = datetime.now() + timedelta(seconds=expires_in)
+            session = Session(token, expires_at, user_id)
+
+            logger.info(f"Successfully authenticated as user {user_id}")
+            return session
+
+        except Exception as e:
+            raise AuthenticationError(f"Login failed: {e}") from e
+
+    def logout(self):
+        """Log out and clear session."""
+        if self._session:
+            try:
+                # Notify server
+                self.http.request(
+                    method="POST",
+                    url="/auth/logout",
+                    headers={"Authorization": f"Bearer {self._session.token}"},
+                )
+            except Exception as e:
+                logger.warning(f"Logout request failed: {e}")
+
+            # Clear local session
+            self._session = None
+            self._clear_saved_session()
+
+    def _load_session(self) -> Optional[Session]:
+        """Load saved session from file."""
+        if not self.config.session_file.exists():
+            return None
+
+        try:
+            with open(self.config.session_file) as f:
+                data = json.load(f)
+            return Session.from_dict(data)
+        except Exception as e:
+            logger.warning(f"Failed to load session: {e}")
+            return None
+
+    def _save_session(self, session: Session):
+        """Save session to file."""
+        try:
+            # Ensure directory exists
+            self.config.session_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # Save with restricted permissions
+            with open(self.config.session_file, "w") as f:
+                json.dump(session.to_dict(), f)
+
+            # Set file permissions (Unix only)
+            try:
+                os.chmod(self.config.session_file, 0o600)
+            except AttributeError:
+                pass  # Windows doesn't support chmod
+
+        except Exception as e:
+            logger.warning(f"Failed to save session: {e}")
+
+    def _clear_saved_session(self):
+        """Remove saved session file."""
+        try:
+            if self.config.session_file.exists():
+                self.config.session_file.unlink()
+        except Exception as e:
+            logger.warning(f"Failed to clear session: {e}")
+
+
+def ensure_initialized() -> bool:
+    """Ensure Flow is properly configured, launching interactive setup if needed.
+
+    Returns:
+        True if configuration is valid, False if setup was cancelled
+    """
+    from flow._internal.config_loader import ConfigLoader
+
+    loader = ConfigLoader()
+    if loader.has_valid_config():
+        return True
+
+    # No valid configuration found - launch interactive setup
+    print("\nNo Flow configuration found. Run setup to configure.\n")
+    return False
+
+
+def validate_config() -> bool:
+    """Validate current configuration and connectivity.
+
+    Returns:
+        True if configuration is valid and API is reachable
+    """
+    try:
+        from flow import Flow
+
+        # Try to create client - this will validate credentials
+        client = Flow()
+        # Try a simple API call to verify connectivity
+        try:
+            client.status("test-connection")
+        except Exception as e:
+            # If error is "not found", auth worked
+            if "not found" in str(e).lower():
+                return True
+            raise
+        return True
+    except AuthenticationError:
+        logger.error("Authentication failed - invalid API key")
+        return False
+    except Exception as e:
+        logger.error(f"Configuration validation failed: {e}")
+        return False
+
+
+def create_authenticator(
+    api_key: Optional[str] = None,
+    email: Optional[str] = None,
+    password: Optional[str] = None,
+    http_client: Optional[IHttpClient] = None,
+) -> Authenticator:
+    """Create authenticator with config.
+
+    Args:
+        api_key: API key (or from FCP_API_KEY env)
+        email: Email for login
+        password: Password for login
+        http_client: HTTP client to use
+
+    Returns:
+        Configured authenticator
+    """
+    from flow._internal.io.http import HttpClient
+
+    config = AuthConfig(api_key=api_key, email=email, password=password)
+
+    if not http_client:
+        # Create basic HTTP client for auth requests
+        http_client = HttpClient(
+            base_url=os.getenv("FCP_API_URL", "https://api.mlfoundry.com"),
+        )
+
+    return Authenticator(config, http_client)

flow/_internal/config.py

@@ -0,0 +1,217 @@
+"""Configuration for Flow SDK.
+
+Clean, provider-agnostic configuration system that separates
+core SDK configuration from provider-specific settings.
+"""
+
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional, Type
+
+
+@dataclass
+class Config:
+    """Provider-agnostic Flow SDK configuration.
+
+    Core configuration that works across all providers. This class provides
+    a unified interface for managing authentication and provider settings
+    regardless of the underlying compute provider.
+
+    Attributes:
+        provider: The compute provider to use (e.g., 'fcp').
+        auth_token: Authentication token for API access.
+        provider_config: Dictionary of provider-specific settings.
+
+    Example:
+        >>> # Create config from environment
+        >>> config = Config.from_env()
+
+        >>> # Create config manually
+        >>> config = Config(
+        ...     provider="fcp",
+        ...     auth_token="your-api-key",
+        ...     provider_config={
+        ...         "project": "my-project",
+        ...         "region": "us-east-1"
+        ...     }
+        ... )
+    """
+
+    provider: str = "fcp"
+    auth_token: Optional[str] = None
+    provider_config: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_env(cls, require_auth: bool = True) -> "Config":
+        """Create config from environment variables and config files.
+
+        Loads configuration from multiple sources in precedence order:
+        1. Environment variables (highest priority)
+        2. flow.yaml in current directory
+        3. ~/.flow/config.yaml (lowest priority)
+
+        Environment variables:
+            FLOW_PROVIDER: Provider to use (default: fcp)
+            FCP_API_KEY: Authentication token for FCP provider
+            FCP_DEFAULT_PROJECT: Default project for FCP
+            FCP_DEFAULT_REGION: Default region for FCP
+            FCP_SSH_KEYS: Comma-separated SSH key names
+
+        Args:
+            require_auth: Whether to require authentication token.
+                         Set to False for operations that don't need auth.
+
+        Returns:
+            Config: Loaded configuration object.
+
+        Raises:
+            ValueError: If authentication is required but not configured.
+
+        Example:
+            >>> # Load config requiring authentication
+            >>> config = Config.from_env(require_auth=True)
+
+            >>> # Load config for local operations
+            >>> config = Config.from_env(require_auth=False)
+        """
+        from flow._internal.config_loader import ConfigLoader
+
+        # Load from all sources with proper precedence
+        loader = ConfigLoader()
+        sources = loader.load_all_sources()
+
+        provider = sources.provider
+        auth_token = sources.api_key
+
+        # Load provider-specific config
+        provider_config = {}
+        if provider == "fcp":
+            provider_config = sources.get_fcp_config()
+
+        # Validate auth if required
+        if require_auth and (not auth_token or auth_token.startswith("YOUR_")):
+            raise ValueError(
+                "Authentication not configured. Please either:\n"
+                "1. Set FCP_API_KEY environment variable\n"
+                "2. Run 'flow init' to set up authentication\n"
+                "3. For tests, ensure FLOW_DISABLE_KEYCHAIN=1 is set"
+            )
+
+        return cls(provider=provider, auth_token=auth_token, provider_config=provider_config)
+
+    def get_headers(self) -> Dict[str, str]:
+        """Get HTTP headers for API requests.
+
+        Returns:
+            Dict[str, str]: Headers including authorization and content type.
+
+        Example:
+            >>> config = Config(auth_token="abc123")
+            >>> headers = config.get_headers()
+            >>> headers
+            {'Authorization': 'Bearer abc123', 'Content-Type': 'application/json'}
+        """
+        return {
+            "Authorization": f"Bearer {self.auth_token}",
+            "Content-Type": "application/json",
+        }
+
+
+# Provider-specific configuration classes
+@dataclass
+class FCPConfig:
+    """FCP (Foundry Cloud Platform) provider-specific configuration.
+
+    Attributes:
+        api_url: Base URL for FCP API endpoints.
+        project: FCP project identifier.
+        region: Default region for resource creation.
+        ssh_keys: List of SSH key names for instance access.
+
+    Example:
+        >>> fcp_config = FCPConfig(
+        ...     project="my-project",
+        ...     region="us-east-1",
+        ...     ssh_keys=["my-key", "team-key"]
+        ... )
+    """
+
+    api_url: str = field(
+        default_factory=lambda: os.getenv("FCP_API_URL", "https://api.mlfoundry.com")
+    )
+    project: Optional[str] = None
+    region: Optional[str] = None
+    ssh_keys: Optional[list[str]] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FCPConfig":
+        """Create FCPConfig from dictionary.
+
+        Args:
+            data: Dictionary containing configuration values.
+                  Unknown keys are ignored.
+
+        Returns:
+            FCPConfig: Configuration object with values from dictionary.
+
+        Example:
+            >>> config_dict = {
+            ...     "project": "ml-training",
+            ...     "region": "us-west-2",
+            ...     "ssh_keys": ["dev-key"],
+            ...     "unknown_key": "ignored"
+            ... }
+            >>> fcp_config = FCPConfig.from_dict(config_dict)
+            >>> fcp_config.project
+            'ml-training'
+        """
+        # Get default api_url from environment if not in data
+        default_api_url = os.getenv("FCP_API_URL", "https://api.mlfoundry.com")
+
+        return cls(
+            api_url=data.get("api_url", default_api_url),
+            project=data.get("project"),
+            region=data.get("region"),
+            ssh_keys=data.get("ssh_keys"),
+        )
+
+    @property
+    def api_key(self) -> Optional[str]:
+        """Legacy property for compatibility during migration.
+
+        This will be removed once all provider code is updated.
+        """
+        # Temporary: Auth token retrieval during migration period
+        # TODO: Remove once provider code is updated to use main Config
+        return os.environ.get("FCP_API_KEY")
+
+
+# Registry for provider configurations
+PROVIDER_CONFIGS: Dict[str, Type] = {
+    "fcp": FCPConfig,
+}
+
+
+def get_provider_config_class(provider: str) -> Type:
+    """Get the configuration class for a provider.
+
+    Args:
+        provider: Provider name (e.g., 'fcp').
+
+    Returns:
+        Type: The configuration class for the specified provider.
+
+    Raises:
+        ValueError: If the provider is not recognized.
+
+    Example:
+        >>> config_class = get_provider_config_class("fcp")
+        >>> config_class.__name__
+        'FCPConfig'
+    """
+    if provider not in PROVIDER_CONFIGS:
+        raise ValueError(
+            f"Unknown provider: {provider}. "
+            f"Available providers: {', '.join(PROVIDER_CONFIGS.keys())}"
+        )
+    return PROVIDER_CONFIGS[provider]