pltr-cli 0.1.0__py3-none-any.whl

pltr/commands/dataset.py

@@ -0,0 +1,98 @@
+"""
+Simplified dataset commands that work with foundry-platform-sdk v1.27.0.
+"""
+
+import typer
+from typing import Optional
+from rich.console import Console
+
+from ..services.dataset import DatasetService
+from ..utils.formatting import OutputFormatter
+from ..utils.progress import SpinnerProgressTracker
+from ..auth.base import ProfileNotFoundError, MissingCredentialsError
+
+app = typer.Typer()
+console = Console()
+formatter = OutputFormatter(console)
+
+
+@app.command("get")
+def get_dataset(
+    dataset_rid: str = typer.Argument(..., help="Dataset Resource Identifier"),
+    profile: Optional[str] = typer.Option(None, "--profile", "-p", help="Profile name"),
+    format: str = typer.Option(
+        "table", "--format", "-f", help="Output format (table, json, csv)"
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get detailed information about a specific dataset."""
+    try:
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching dataset {dataset_rid}..."
+        ):
+            dataset = service.get_dataset(dataset_rid)
+
+        formatter.format_dataset_detail(dataset, format, output)
+
+        if output:
+            formatter.print_success(f"Dataset information saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to get dataset: {e}")
+        raise typer.Exit(1)
+
+
+# schema command removed - uses preview-only API that returns INVALID_ARGUMENT
+
+
+@app.command("create")
+def create_dataset(
+    name: str = typer.Argument(..., help="Dataset name"),
+    profile: Optional[str] = typer.Option(None, "--profile", "-p", help="Profile name"),
+    parent_folder: Optional[str] = typer.Option(
+        None, "--parent-folder", help="Parent folder RID"
+    ),
+    format: str = typer.Option(
+        "table", "--format", "-f", help="Output format (table, json, csv)"
+    ),
+):
+    """Create a new dataset."""
+    try:
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(f"Creating dataset '{name}'..."):
+            dataset = service.create_dataset(name=name, parent_folder_rid=parent_folder)
+
+        formatter.print_success(f"Successfully created dataset '{name}'")
+        formatter.print_info(f"Dataset RID: {dataset.get('rid', 'unknown')}")
+
+        # Show dataset details
+        formatter.format_dataset_detail(dataset, format)
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to create dataset: {e}")
+        raise typer.Exit(1)
+
+
+@app.callback()
+def main():
+    """
+    Dataset operations using foundry-platform-sdk.
+
+    Note: This SDK version requires knowing dataset RIDs in advance.
+    Find dataset RIDs in the Foundry web interface.
+
+    Available commands work with Resource Identifiers (RIDs) like:
+    ri.foundry.main.dataset.12345678-1234-1234-1234-123456789abc
+    """
+    pass

pltr/commands/verify.py

@@ -0,0 +1,185 @@
+"""
+Verification command to test authentication.
+"""
+
+import typer
+import requests
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+
+from ..auth.manager import AuthManager
+from ..auth.base import (
+    ProfileNotFoundError,
+    MissingCredentialsError,
+    InvalidCredentialsError,
+)
+
+app = typer.Typer()
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def verify(
+    ctx: typer.Context,
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile to verify"
+    ),
+):
+    """Verify authentication by connecting to Palantir Foundry."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    auth_manager = AuthManager()
+
+    # Show which profile we're using
+    active_profile = profile or auth_manager.get_current_profile()
+    if not active_profile:
+        console.print("[red]Error:[/red] No profile configured")
+        console.print("Run 'pltr configure configure' to set up authentication")
+        raise typer.Exit(1)
+
+    console.print(f"Verifying profile: [bold]{active_profile}[/bold]")
+
+    try:
+        # Get credentials directly without creating SDK client
+        from ..auth.storage import CredentialStorage
+
+        storage = CredentialStorage()
+
+        # Get credentials for the profile
+        try:
+            credentials = storage.get_profile(active_profile)
+        except ProfileNotFoundError:
+            console.print(f"[red]Error:[/red] Profile '{active_profile}' not found")
+            raise typer.Exit(1)
+
+        # Extract authentication details
+        host = credentials.get("host")
+        auth_type = credentials.get("auth_type")
+
+        if not host:
+            console.print(
+                f"[red]Error:[/red] No host URL configured for profile '{active_profile}'"
+            )
+            raise typer.Exit(1)
+
+        # Prepare the request
+        url = f"{host}/multipass/api/me"
+        headers = {}
+
+        # Set up authentication headers based on type
+        if auth_type == "token":
+            token = credentials.get("token")
+            if not token:
+                console.print(
+                    f"[red]Error:[/red] No token configured for profile '{active_profile}'"
+                )
+                raise typer.Exit(1)
+            headers["Authorization"] = f"Bearer {token}"
+
+        elif auth_type == "oauth":
+            # OAuth - need to get access token first
+            client_id = credentials.get("client_id")
+            client_secret = credentials.get("client_secret")
+
+            if not client_id or not client_secret:
+                console.print(
+                    f"[red]Error:[/red] OAuth credentials incomplete for profile '{active_profile}'"
+                )
+                raise typer.Exit(1)
+
+            token_url = f"{host}/multipass/api/oauth2/token"
+            token_response = requests.post(
+                token_url,
+                data={
+                    "grant_type": "client_credentials",
+                    "client_id": client_id,
+                    "client_secret": client_secret,
+                },
+            )
+            if token_response.status_code == 200:
+                access_token = token_response.json().get("access_token")
+                headers["Authorization"] = f"Bearer {access_token}"
+            else:
+                console.print(
+                    f"[red]Error:[/red] Failed to get OAuth token: {token_response.text}"
+                )
+                raise typer.Exit(1)
+
+        # Make the request to /multipass/api/me
+        response = requests.get(url, headers=headers)
+
+        if response.status_code == 200:
+            user_info = response.json()
+
+            # Display success with user information
+            console.print("[green]✓[/green] Authentication successful!")
+            console.print()
+
+            # Create a table with user information
+            table = Table(title="User Information", show_header=False)
+            table.add_column("Field", style="cyan")
+            table.add_column("Value")
+
+            # Add user details
+            table.add_row("Username", user_info.get("username", "N/A"))
+            table.add_row("Email", user_info.get("email", "N/A"))
+            table.add_row("User ID", user_info.get("id", "N/A"))
+
+            # Add organization info if available
+            if "organization" in user_info:
+                table.add_row(
+                    "Organization", user_info["organization"].get("rid", "N/A")
+                )
+
+            # Add groups if available
+            if "groups" in user_info and user_info["groups"]:
+                groups_list = ", ".join(
+                    g.get("name", "N/A") for g in user_info["groups"][:3]
+                )
+                if len(user_info["groups"]) > 3:
+                    groups_list += f" (+{len(user_info['groups']) - 3} more)"
+                table.add_row("Groups", groups_list)
+
+            console.print(table)
+            console.print()
+            console.print(
+                f"[green]Profile '{active_profile}' is properly configured![/green]"
+            )
+
+        elif response.status_code == 401:
+            console.print("[red]✗[/red] Authentication failed: Invalid credentials")
+            console.print(
+                f"Please check your token/credentials for profile '{active_profile}'"
+            )
+            raise typer.Exit(1)
+        elif response.status_code == 403:
+            console.print("[red]✗[/red] Authentication failed: Access forbidden")
+            console.print(
+                "Your credentials are valid but you don't have access to this endpoint"
+            )
+            raise typer.Exit(1)
+        else:
+            console.print(f"[red]✗[/red] Request failed: {response.status_code}")
+            console.print(f"Response: {response.text}")
+            raise typer.Exit(1)
+
+    except ProfileNotFoundError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except MissingCredentialsError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except InvalidCredentialsError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except requests.exceptions.ConnectionError:
+        console.print(
+            "[red]✗[/red] Connection failed: Unable to reach the Foundry host"
+        )
+        console.print("Please check your network connection and host URL")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] Unexpected error: {e}")
+        raise typer.Exit(1)

pltr/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration management for pltr."""

pltr/config/profiles.py

@@ -0,0 +1,124 @@
+"""
+Profile management for pltr CLI.
+"""
+
+import json
+from typing import List, Optional
+
+from .settings import Settings
+
+
+class ProfileManager:
+    """Manages authentication profiles."""
+
+    def __init__(self):
+        """Initialize profile manager."""
+        self.settings = Settings()
+        self.profiles_file = self.settings.config_dir / "profiles.json"
+        self._profiles = self._load_profiles()
+
+    def _load_profiles(self) -> dict:
+        """Load profiles from file."""
+        if not self.profiles_file.exists():
+            return {"profiles": [], "default": None}
+
+        try:
+            with open(self.profiles_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {"profiles": [], "default": None}
+
+    def _save_profiles(self) -> None:
+        """Save profiles to file."""
+        with open(self.profiles_file, "w") as f:
+            json.dump(self._profiles, f, indent=2)
+
+    def add_profile(self, profile: str) -> None:
+        """
+        Add a new profile.
+
+        Args:
+            profile: Profile name
+        """
+        if profile not in self._profiles["profiles"]:
+            self._profiles["profiles"].append(profile)
+            self._save_profiles()
+
+    def remove_profile(self, profile: str) -> None:
+        """
+        Remove a profile.
+
+        Args:
+            profile: Profile name
+        """
+        if profile in self._profiles["profiles"]:
+            self._profiles["profiles"].remove(profile)
+
+            # If this was the default profile, clear the default
+            if self._profiles["default"] == profile:
+                self._profiles["default"] = None
+                # Set a new default if there are other profiles
+                if self._profiles["profiles"]:
+                    self._profiles["default"] = self._profiles["profiles"][0]
+
+            self._save_profiles()
+
+    def list_profiles(self) -> List[str]:
+        """
+        List all profiles.
+
+        Returns:
+            List of profile names
+        """
+        return self._profiles["profiles"].copy()
+
+    def get_default(self) -> Optional[str]:
+        """
+        Get the default profile.
+
+        Returns:
+            Default profile name or None
+        """
+        return self._profiles["default"]
+
+    def set_default(self, profile: str) -> None:
+        """
+        Set the default profile.
+
+        Args:
+            profile: Profile name
+        """
+        if profile in self._profiles["profiles"]:
+            self._profiles["default"] = profile
+            self._save_profiles()
+            # Also update in settings
+            self.settings.set("default_profile", profile)
+
+    def profile_exists(self, profile: str) -> bool:
+        """
+        Check if a profile exists.
+
+        Args:
+            profile: Profile name
+
+        Returns:
+            True if profile exists, False otherwise
+        """
+        return profile in self._profiles["profiles"]
+
+    def get_active_profile(self) -> Optional[str]:
+        """
+        Get the active profile (from environment or default).
+
+        Returns:
+            Active profile name
+        """
+        import os
+
+        # Check environment variable first
+        env_profile = os.environ.get("PLTR_PROFILE")
+        if env_profile and self.profile_exists(env_profile):
+            return env_profile
+
+        # Fall back to default
+        return self.get_default()

pltr/config/settings.py

@@ -0,0 +1,103 @@
+"""
+Configuration settings management for pltr CLI.
+"""
+
+import os
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+
+class Settings:
+    """Manages application settings and configuration."""
+
+    def __init__(self):
+        """Initialize settings manager."""
+        self.config_dir = self._get_config_dir()
+        self.settings_file = self.config_dir / "settings.json"
+        self._ensure_config_dir()
+        self._settings = self._load_settings()
+
+    def _get_config_dir(self) -> Path:
+        """Get the configuration directory path."""
+        # Follow XDG Base Directory specification
+        xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+        if xdg_config_home:
+            return Path(xdg_config_home) / "pltr"
+
+        # Default to ~/.config/pltr
+        return Path.home() / ".config" / "pltr"
+
+    def _ensure_config_dir(self) -> None:
+        """Ensure configuration directory exists."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def _load_settings(self) -> Dict[str, Any]:
+        """Load settings from file."""
+        if not self.settings_file.exists():
+            return self._get_default_settings()
+
+        try:
+            with open(self.settings_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return self._get_default_settings()
+
+    def _get_default_settings(self) -> Dict[str, Any]:
+        """Get default settings."""
+        return {
+            "default_profile": "default",
+            "output_format": "table",
+            "color_output": True,
+            "page_size": 20,
+            "timeout": 30,
+            "verify_ssl": True,
+        }
+
+    def save(self) -> None:
+        """Save settings to file."""
+        with open(self.settings_file, "w") as f:
+            json.dump(self._settings, f, indent=2)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get a setting value.
+
+        Args:
+            key: Setting key
+            default: Default value if key doesn't exist
+
+        Returns:
+            Setting value or default
+        """
+        return self._settings.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        """
+        Set a setting value.
+
+        Args:
+            key: Setting key
+            value: Setting value
+        """
+        self._settings[key] = value
+        self.save()
+
+    def update(self, settings: Dict[str, Any]) -> None:
+        """
+        Update multiple settings.
+
+        Args:
+            settings: Dictionary of settings to update
+        """
+        self._settings.update(settings)
+        self.save()
+
+    def reset(self) -> None:
+        """Reset settings to defaults."""
+        self._settings = self._get_default_settings()
+        self.save()
+
+    def get_all(self) -> Dict[str, Any]:
+        """Get all settings."""
+        return self._settings.copy()

pltr/services/__init__.py

@@ -0,0 +1 @@
+"""Service wrappers for Foundry SDK."""

pltr/services/base.py

@@ -0,0 +1,62 @@
+"""
+Base service class for Foundry API wrappers.
+"""
+
+from typing import Any, Optional
+from abc import ABC, abstractmethod
+
+from ..auth.manager import AuthManager
+
+
+class BaseService(ABC):
+    """Base class for Foundry service wrappers."""
+
+    def __init__(self, profile: Optional[str] = None):
+        """
+        Initialize base service.
+
+        Args:
+            profile: Authentication profile name (uses default if not specified)
+        """
+        self.profile = profile
+        self.auth_manager = AuthManager()
+        self._client: Optional[Any] = None
+
+    @property
+    def client(self) -> Any:
+        """
+        Get authenticated Foundry client.
+
+        Returns:
+            Configured FoundryClient instance
+
+        Raises:
+            ProfileNotFoundError: If profile doesn't exist
+            MissingCredentialsError: If credentials are incomplete
+        """
+        if self._client is None:
+            self._client = self.auth_manager.get_client(self.profile)
+        return self._client
+
+    @abstractmethod
+    def _get_service(self) -> Any:
+        """
+        Get the specific Foundry SDK service instance.
+
+        Returns:
+            Configured service instance from foundry-platform-sdk
+
+        This method should be implemented by subclasses to return the
+        appropriate service (e.g., client.datasets, client.ontology)
+        """
+        pass
+
+    @property
+    def service(self) -> Any:
+        """
+        Get the Foundry SDK service instance.
+
+        Returns:
+            Configured service instance
+        """
+        return self._get_service()

pltr/services/dataset.py

@@ -0,0 +1,90 @@
+"""
+Dataset service wrapper for Foundry SDK v2 API.
+Only includes operations that are actually supported by foundry-platform-sdk v1.27.0.
+"""
+
+from typing import Any, Optional, Dict
+
+from .base import BaseService
+
+
+class DatasetService(BaseService):
+    """Service wrapper for Foundry dataset operations using v2 API."""
+
+    def _get_service(self) -> Any:
+        """Get the Foundry datasets service."""
+        return self.client.datasets
+
+    def get_dataset(self, dataset_rid: str) -> Dict[str, Any]:
+        """
+        Get information about a specific dataset.
+
+        Args:
+            dataset_rid: Dataset Resource Identifier
+
+        Returns:
+            Dataset information dictionary
+        """
+        try:
+            # Use the v2 API's Dataset.get method
+            dataset = self.service.Dataset.get(dataset_rid)
+            return self._format_dataset_info(dataset)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get dataset {dataset_rid}: {e}")
+
+    # get_schema method removed - uses preview-only API
+
+    def create_dataset(
+        self, name: str, parent_folder_rid: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Create a new dataset.
+
+        Args:
+            name: Dataset name
+            parent_folder_rid: Parent folder RID (optional)
+
+        Returns:
+            Created dataset information
+        """
+        try:
+            # The create method parameters depend on the SDK version
+            dataset = self.service.Dataset.create(
+                name=name, parent_folder_rid=parent_folder_rid
+            )
+            return self._format_dataset_info(dataset)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create dataset '{name}': {e}")
+
+    def read_table(self, dataset_rid: str, format: str = "arrow") -> Any:
+        """
+        Read dataset as a table.
+
+        Args:
+            dataset_rid: Dataset Resource Identifier
+            format: Output format (arrow, pandas, etc.)
+
+        Returns:
+            Table data in specified format
+        """
+        try:
+            return self.service.Dataset.read_table(dataset_rid, format=format)
+        except Exception as e:
+            raise RuntimeError(f"Failed to read dataset {dataset_rid}: {e}")
+
+    def _format_dataset_info(self, dataset: Any) -> Dict[str, Any]:
+        """
+        Format dataset information for consistent output.
+
+        Args:
+            dataset: Dataset object from Foundry SDK
+
+        Returns:
+            Formatted dataset information dictionary
+        """
+        # The v2 Dataset object only has rid, name, and parent_folder_rid
+        return {
+            "rid": dataset.rid,
+            "name": dataset.name,
+            "parent_folder_rid": dataset.parent_folder_rid,
+        }