pltr-cli 0.1.0__py3-none-any.whl

pltr/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pltr/auth/__init__.py

@@ -0,0 +1 @@
+"""Authentication module for pltr."""

pltr/auth/base.py

@@ -0,0 +1,49 @@
+"""
+Base authentication classes for Palantir Foundry.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+
+class AuthProvider(ABC):
+    """Abstract base class for authentication providers."""
+
+    @abstractmethod
+    def get_client(self) -> Any:
+        """Return an authenticated Foundry client."""
+        pass
+
+    @abstractmethod
+    def validate(self) -> bool:
+        """Validate authentication credentials."""
+        pass
+
+    @abstractmethod
+    def get_config(self) -> Dict[str, Any]:
+        """Return authentication configuration."""
+        pass
+
+
+class AuthError(Exception):
+    """Base exception for authentication errors."""
+
+    pass
+
+
+class InvalidCredentialsError(AuthError):
+    """Raised when credentials are invalid."""
+
+    pass
+
+
+class MissingCredentialsError(AuthError):
+    """Raised when required credentials are missing."""
+
+    pass
+
+
+class ProfileNotFoundError(AuthError):
+    """Raised when a profile cannot be found."""
+
+    pass

pltr/auth/manager.py

@@ -0,0 +1,129 @@
+"""
+Authentication manager for getting configured Foundry clients.
+"""
+
+from typing import Optional, Any
+
+from .base import AuthProvider, ProfileNotFoundError, MissingCredentialsError
+from .storage import CredentialStorage
+from .token import TokenAuthProvider
+from .oauth import OAuthClientProvider
+from ..config.profiles import ProfileManager
+
+
+class AuthManager:
+    """Manages authentication and provides configured Foundry clients."""
+
+    def __init__(self):
+        """Initialize authentication manager."""
+        self.storage = CredentialStorage()
+        self.profile_manager = ProfileManager()
+
+    def get_client(self, profile: Optional[str] = None) -> Any:
+        """
+        Get an authenticated Foundry client for a profile.
+
+        Args:
+            profile: Profile name (uses active profile if not specified)
+
+        Returns:
+            Configured FoundryClient instance
+
+        Raises:
+            ProfileNotFoundError: If profile doesn't exist
+            MissingCredentialsError: If credentials are incomplete
+        """
+        # Determine which profile to use
+        if not profile:
+            profile = self.profile_manager.get_active_profile()
+            if not profile:
+                raise ProfileNotFoundError(
+                    "No profile specified and no default profile configured. "
+                    "Run 'pltr configure configure' to set up authentication."
+                )
+
+        # Get credentials for the profile
+        try:
+            credentials = self.storage.get_profile(profile)
+        except ProfileNotFoundError:
+            raise ProfileNotFoundError(
+                f"Profile '{profile}' not found. "
+                f"Run 'pltr configure configure --profile {profile}' to set it up."
+            )
+
+        # Create appropriate auth provider
+        provider = self._create_provider(credentials)
+
+        # Return authenticated client
+        return provider.get_client()
+
+    def _create_provider(self, credentials: dict) -> AuthProvider:
+        """
+        Create an auth provider from credentials.
+
+        Args:
+            credentials: Dictionary containing auth configuration
+
+        Returns:
+            Configured AuthProvider instance
+
+        Raises:
+            MissingCredentialsError: If auth type is unknown or credentials incomplete
+        """
+        auth_type = credentials.get("auth_type")
+        host = credentials.get("host")
+
+        if not auth_type:
+            raise MissingCredentialsError(
+                "Authentication type not specified in credentials"
+            )
+        if not host:
+            raise MissingCredentialsError("Host URL not specified in credentials")
+
+        if auth_type == "token":
+            token = credentials.get("token")
+            if not token:
+                raise MissingCredentialsError("Token not found in credentials")
+            return TokenAuthProvider(token=token, host=host)
+
+        elif auth_type == "oauth":
+            client_id = credentials.get("client_id")
+            client_secret = credentials.get("client_secret")
+            if not client_id or not client_secret:
+                raise MissingCredentialsError("OAuth client credentials incomplete")
+            return OAuthClientProvider(
+                client_id=client_id,
+                client_secret=client_secret,
+                host=host,
+                scopes=credentials.get("scopes", []),
+            )
+
+        else:
+            raise MissingCredentialsError(f"Unknown authentication type: {auth_type}")
+
+    def get_current_profile(self) -> Optional[str]:
+        """
+        Get the name of the currently active profile.
+
+        Returns:
+            Profile name or None if no profile is configured
+        """
+        return self.profile_manager.get_active_profile()
+
+    def validate_profile(self, profile: Optional[str] = None) -> bool:
+        """
+        Validate that a profile's credentials work.
+
+        Args:
+            profile: Profile name (uses active profile if not specified)
+
+        Returns:
+            True if credentials are valid
+
+        Raises:
+            Exception if validation fails
+        """
+        self.get_client(profile)
+        # The actual validation will happen when we try to use the client
+        # in the verify command
+        return True

pltr/auth/oauth.py

@@ -0,0 +1,83 @@
+"""
+OAuth2 client authentication for Palantir Foundry.
+"""
+
+import os
+from typing import Dict, Optional, Any
+
+from .base import AuthProvider, InvalidCredentialsError, MissingCredentialsError
+
+
+class OAuthClientProvider(AuthProvider):
+    """Authentication provider using OAuth2 client credentials."""
+
+    def __init__(
+        self,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        host: Optional[str] = None,
+        scopes: Optional[list] = None,
+    ):
+        """
+        Initialize OAuth2 client authentication.
+
+        Args:
+            client_id: OAuth2 client ID
+            client_secret: OAuth2 client secret
+            host: Foundry host URL (e.g., 'https://your-stack.palantirfoundry.com')
+            scopes: List of scopes to request
+        """
+        self.client_id = client_id or os.environ.get("FOUNDRY_CLIENT_ID")
+        self.client_secret = client_secret or os.environ.get("FOUNDRY_CLIENT_SECRET")
+        self.host = host or os.environ.get("FOUNDRY_HOST")
+        self.scopes = scopes or []
+
+        if not self.client_id:
+            raise MissingCredentialsError(
+                "Client ID is required for OAuth authentication"
+            )
+        if not self.client_secret:
+            raise MissingCredentialsError(
+                "Client secret is required for OAuth authentication"
+            )
+        if not self.host:
+            raise MissingCredentialsError(
+                "Host URL is required for OAuth authentication"
+            )
+
+    def get_client(self) -> Any:
+        """Return an authenticated Foundry client."""
+        from foundry_sdk import FoundryClient, ConfidentialClientAuth
+
+        auth = ConfidentialClientAuth(
+            client_id=self.client_id,  # type: ignore
+            client_secret=self.client_secret,  # type: ignore
+            scopes=self.scopes,
+        )
+        return FoundryClient(auth=auth, hostname=self.host)
+
+    def validate(self) -> bool:
+        """Validate authentication credentials."""
+        try:
+            self.get_client()
+            # Try to make a simple API call to validate the credentials
+            # This would need to be replaced with an actual validation call
+            # when the SDK provides one
+            return True
+        except Exception as e:
+            raise InvalidCredentialsError(f"OAuth validation failed: {e}")
+
+    def get_config(self) -> Dict[str, Any]:
+        """Return authentication configuration."""
+        return {
+            "type": "oauth",
+            "host": self.host,
+            "client_id": self.client_id,
+            "client_secret": "***"
+            + (
+                self.client_secret[-4:]
+                if self.client_secret and len(self.client_secret) > 4
+                else ""
+            ),
+            "scopes": self.scopes,
+        }

pltr/auth/storage.py

@@ -0,0 +1,87 @@
+"""
+Secure credential storage using keyring.
+"""
+
+import json
+import keyring
+from typing import Dict, Any
+
+from .base import ProfileNotFoundError
+
+
+class CredentialStorage:
+    """Manages secure storage of authentication credentials."""
+
+    SERVICE_NAME = "pltr-cli"
+
+    def __init__(self):
+        """Initialize credential storage."""
+        self.keyring = keyring
+
+    def save_profile(self, profile: str, credentials: Dict[str, Any]) -> None:
+        """
+        Save credentials for a profile.
+
+        Args:
+            profile: Profile name
+            credentials: Dictionary of credentials to store
+        """
+        # Convert credentials to JSON string for storage
+        credentials_json = json.dumps(credentials)
+        self.keyring.set_password(self.SERVICE_NAME, profile, credentials_json)
+
+    def get_profile(self, profile: str) -> Dict[str, Any]:
+        """
+        Retrieve credentials for a profile.
+
+        Args:
+            profile: Profile name
+
+        Returns:
+            Dictionary of stored credentials
+
+        Raises:
+            ProfileNotFoundError: If profile doesn't exist
+        """
+        credentials_json = self.keyring.get_password(self.SERVICE_NAME, profile)
+        if not credentials_json:
+            raise ProfileNotFoundError(f"Profile '{profile}' not found")
+
+        return json.loads(credentials_json)
+
+    def delete_profile(self, profile: str) -> None:
+        """
+        Delete a profile's credentials.
+
+        Args:
+            profile: Profile name
+        """
+        try:
+            self.keyring.delete_password(self.SERVICE_NAME, profile)
+        except keyring.errors.PasswordDeleteError:
+            raise ProfileNotFoundError(f"Profile '{profile}' not found")
+
+    def list_profiles(self) -> list:
+        """
+        List all available profiles.
+
+        Returns:
+            List of profile names
+        """
+        # Note: keyring doesn't provide a direct way to list all usernames
+        # for a service, so we'll need to store this separately in config
+        # This is a placeholder that will be integrated with config/profiles.py
+        return []
+
+    def profile_exists(self, profile: str) -> bool:
+        """
+        Check if a profile exists.
+
+        Args:
+            profile: Profile name
+
+        Returns:
+            True if profile exists, False otherwise
+        """
+        credentials = self.keyring.get_password(self.SERVICE_NAME, profile)
+        return credentials is not None

pltr/auth/token.py

@@ -0,0 +1,55 @@
+"""
+Token-based authentication for Palantir Foundry.
+"""
+
+import os
+from typing import Dict, Optional, Any
+
+from .base import AuthProvider, InvalidCredentialsError, MissingCredentialsError
+
+
+class TokenAuthProvider(AuthProvider):
+    """Authentication provider using bearer tokens."""
+
+    def __init__(self, token: Optional[str] = None, host: Optional[str] = None):
+        """
+        Initialize token authentication.
+
+        Args:
+            token: Bearer token for authentication
+            host: Foundry host URL (e.g., 'https://your-stack.palantirfoundry.com')
+        """
+        self.token = token or os.environ.get("FOUNDRY_TOKEN")
+        self.host = host or os.environ.get("FOUNDRY_HOST")
+
+        if not self.token:
+            raise MissingCredentialsError("Token is required for authentication")
+        if not self.host:
+            raise MissingCredentialsError("Host URL is required for authentication")
+
+    def get_client(self) -> Any:
+        """Return an authenticated Foundry client."""
+        from foundry_sdk import FoundryClient, UserTokenAuth
+
+        auth = UserTokenAuth(token=self.token)  # type: ignore
+        return FoundryClient(auth=auth, hostname=self.host)
+
+    def validate(self) -> bool:
+        """Validate authentication credentials."""
+        try:
+            self.get_client()
+            # Try to make a simple API call to validate the token
+            # This would need to be replaced with an actual validation call
+            # when the SDK provides one
+            return True
+        except Exception as e:
+            raise InvalidCredentialsError(f"Token validation failed: {e}")
+
+    def get_config(self) -> Dict[str, Any]:
+        """Return authentication configuration."""
+        return {
+            "type": "token",
+            "host": self.host,
+            "token": "***"
+            + (self.token[-4:] if self.token and len(self.token) > 4 else ""),
+        }

pltr/cli.py

@@ -0,0 +1,54 @@
+"""
+Main CLI entry point for pltr.
+"""
+
+import typer
+from typing_extensions import Annotated
+
+from pltr import __version__
+from pltr.commands import configure, verify, dataset
+
+app = typer.Typer(
+    name="pltr",
+    help="Command-line interface for Palantir Foundry APIs",
+    no_args_is_help=True,
+)
+
+# Add subcommands
+app.add_typer(configure.app, name="configure", help="Manage authentication profiles")
+app.add_typer(verify.app, name="verify", help="Verify authentication")
+app.add_typer(dataset.app, name="dataset", help="Manage datasets")
+
+
+def version_callback(value: bool):
+    """Show version and exit."""
+    if value:
+        typer.echo(f"pltr {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool, typer.Option("--version", callback=version_callback, help="Show version")
+    ] = False,
+):
+    """
+    Command-line interface for Palantir Foundry APIs.
+
+    Built on top of the official foundry-platform-sdk, pltr provides
+    intuitive commands for dataset management, ontology operations,
+    SQL queries, and more.
+    """
+    pass
+
+
+@app.command()
+def hello():
+    """Test command to verify CLI is working."""
+    typer.echo("Hello from pltr! 🚀")
+    typer.echo("CLI is working correctly.")
+
+
+if __name__ == "__main__":
+    app()

pltr/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for pltr."""

pltr/commands/configure.py

@@ -0,0 +1,151 @@
+"""
+Configuration commands for pltr CLI.
+"""
+
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+
+from ..auth.storage import CredentialStorage
+from ..auth.base import ProfileNotFoundError
+from ..config.profiles import ProfileManager
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command()
+def configure(
+    profile: Optional[str] = typer.Option(
+        "default", "--profile", "-p", help="Profile name"
+    ),
+    auth_type: Optional[str] = typer.Option(
+        None, "--auth-type", help="Authentication type (token or oauth)"
+    ),
+    host: Optional[str] = typer.Option(None, "--host", help="Foundry host URL"),
+    token: Optional[str] = typer.Option(
+        None, "--token", help="Bearer token (for token auth)"
+    ),
+    client_id: Optional[str] = typer.Option(
+        None, "--client-id", help="OAuth client ID"
+    ),
+    client_secret: Optional[str] = typer.Option(
+        None, "--client-secret", help="OAuth client secret"
+    ),
+):
+    """Configure authentication for Palantir Foundry."""
+    storage = CredentialStorage()
+    profile_manager = ProfileManager()
+
+    # Ensure profile is not None
+    if not profile:
+        profile = "default"
+
+    # Check if profile already exists
+    if storage.profile_exists(profile):
+        if not Confirm.ask(f"Profile '{profile}' already exists. Overwrite?"):
+            console.print("[yellow]Configuration cancelled.[/yellow]")
+            raise typer.Exit()
+
+    # Interactive mode if no auth type specified
+    if not auth_type:
+        auth_type = Prompt.ask(
+            "Authentication type", choices=["token", "oauth"], default="token"
+        )
+
+    # Get host URL
+    if not host:
+        host = Prompt.ask(
+            "Foundry host URL", default="https://your-stack.palantirfoundry.com"
+        )
+
+    credentials = {"auth_type": auth_type, "host": host}
+
+    if auth_type == "token":
+        # Token authentication
+        if not token:
+            token = Prompt.ask("Bearer token", password=True)
+        credentials["token"] = token
+
+    elif auth_type == "oauth":
+        # OAuth authentication
+        if not client_id:
+            client_id = Prompt.ask("OAuth client ID")
+        if not client_secret:
+            client_secret = Prompt.ask("OAuth client secret", password=True)
+
+        credentials["client_id"] = client_id
+        credentials["client_secret"] = client_secret
+
+    # Save credentials
+    storage.save_profile(profile, credentials)
+    profile_manager.add_profile(profile)
+
+    # Set as default if it's the first profile
+    if len(profile_manager.list_profiles()) == 1:
+        profile_manager.set_default(profile)
+
+    console.print(f"[green]✓[/green] Profile '{profile}' configured successfully")
+
+
+@app.command()
+def list_profiles():
+    """List all configured profiles."""
+    profile_manager = ProfileManager()
+    profiles = profile_manager.list_profiles()
+    default = profile_manager.get_default()
+
+    if not profiles:
+        console.print("[yellow]No profiles configured.[/yellow]")
+        console.print("Run 'pltr configure' to set up your first profile.")
+        return
+
+    console.print("[bold]Configured profiles:[/bold]")
+    for profile in profiles:
+        if profile == default:
+            console.print(f"  * {profile} [green](default)[/green]")
+        else:
+            console.print(f"    {profile}")
+
+
+@app.command()
+def set_default(
+    profile: str = typer.Argument(..., help="Profile name to set as default"),
+):
+    """Set a profile as the default."""
+    profile_manager = ProfileManager()
+
+    if profile not in profile_manager.list_profiles():
+        console.print(f"[red]Error:[/red] Profile '{profile}' not found")
+        raise typer.Exit(1)
+
+    profile_manager.set_default(profile)
+    console.print(f"[green]✓[/green] Profile '{profile}' set as default")
+
+
+@app.command()
+def delete(
+    profile: str = typer.Argument(..., help="Profile name to delete"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Delete a profile."""
+    storage = CredentialStorage()
+    profile_manager = ProfileManager()
+
+    if profile not in profile_manager.list_profiles():
+        console.print(f"[red]Error:[/red] Profile '{profile}' not found")
+        raise typer.Exit(1)
+
+    if not force:
+        if not Confirm.ask(f"Delete profile '{profile}'?"):
+            console.print("[yellow]Deletion cancelled.[/yellow]")
+            raise typer.Exit()
+
+    try:
+        storage.delete_profile(profile)
+        profile_manager.remove_profile(profile)
+        console.print(f"[green]✓[/green] Profile '{profile}' deleted")
+    except ProfileNotFoundError:
+        console.print(f"[red]Error:[/red] Could not delete profile '{profile}'")
+        raise typer.Exit(1)