pltr-cli 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

pltr/cli.py

@@ -10,12 +10,15 @@ from pltr.commands import (
     configure,
     verify,
     dataset,
+    folder,
     ontology,
+    orchestration,
     sql,
     admin,
     shell,
     completion,
     alias,
+    mediasets,
 )
 
 app = typer.Typer(
@@ -28,8 +31,15 @@ app = typer.Typer(
 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")
+app.add_typer(folder.app, name="folder", help="Manage folders")
 app.add_typer(ontology.app, name="ontology", help="Ontology operations")
+app.add_typer(
+    orchestration.app, name="orchestration", help="Manage builds, jobs, and schedules"
+)
 app.add_typer(sql.app, name="sql", help="Execute SQL queries")
+app.add_typer(
+    mediasets.app, name="media-sets", help="Manage media sets and media content"
+)
 app.add_typer(
     admin.app,
     name="admin",

pltr/commands/dataset.py

@@ -18,6 +18,10 @@ from ..utils.completion import (
 )
 
 app = typer.Typer()
+branches_app = typer.Typer()
+files_app = typer.Typer()
+transactions_app = typer.Typer()
+views_app = typer.Typer()
 console = Console()
 formatter = OutputFormatter(console)
 
@@ -101,6 +105,311 @@ def create_dataset(
         raise typer.Exit(1)
 
 
+# Branch commands
+@branches_app.command("list")
+def list_branches(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """List branches for a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching branches for {dataset_rid}..."
+        ):
+            branches = service.get_branches(dataset_rid)
+
+        formatter.format_branches(branches, format, output)
+
+        if output:
+            formatter.print_success(f"Branches 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 branches: {e}")
+        raise typer.Exit(1)
+
+
+@branches_app.command("create")
+def create_branch(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    branch_name: str = typer.Argument(..., help="Branch name"),
+    parent_branch: str = typer.Option(
+        "master", "--parent", help="Parent branch to branch from"
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+):
+    """Create a new branch for a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Creating branch '{branch_name}' from '{parent_branch}'..."
+        ):
+            branch = service.create_branch(dataset_rid, branch_name, parent_branch)
+
+        formatter.print_success(f"Successfully created branch '{branch_name}'")
+        formatter.format_branch_detail(branch, 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 branch: {e}")
+        raise typer.Exit(1)
+
+
+# Files commands
+@files_app.command("list")
+def list_files(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    branch: str = typer.Option("master", "--branch", help="Dataset branch"),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """List files in a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching files from {dataset_rid} (branch: {branch})..."
+        ):
+            files = service.list_files(dataset_rid, branch)
+
+        formatter.format_files(files, format, output)
+
+        if output:
+            formatter.print_success(f"Files 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 list files: {e}")
+        raise typer.Exit(1)
+
+
+@files_app.command("get")
+def get_file(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    file_path: str = typer.Argument(..., help="Path of file within dataset"),
+    output_path: str = typer.Argument(..., help="Local path to save the file"),
+    branch: str = typer.Option("master", "--branch", help="Dataset branch"),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+):
+    """Download a file from a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Downloading {file_path} from {dataset_rid}..."
+        ):
+            result = service.download_file(dataset_rid, file_path, output_path, branch)
+
+        formatter.print_success(f"File downloaded to {result['output_path']}")
+        formatter.print_info(f"Size: {result.get('size_bytes', 'unknown')} bytes")
+
+    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 download file: {e}")
+        raise typer.Exit(1)
+
+
+# Transaction commands
+@transactions_app.command("list")
+def list_transactions(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    branch: str = typer.Option("master", "--branch", help="Dataset branch"),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """List transactions for a dataset branch."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching transactions for {dataset_rid} (branch: {branch})..."
+        ):
+            transactions = service.get_transactions(dataset_rid, branch)
+
+        formatter.format_transactions(transactions, format, output)
+
+        if output:
+            formatter.print_success(f"Transactions information saved to {output}")
+
+    except NotImplementedError as e:
+        formatter.print_warning(f"Feature not available: {e}")
+        raise typer.Exit(0)
+    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 list transactions: {e}")
+        raise typer.Exit(1)
+
+
+# Views commands
+@views_app.command("list")
+def list_views(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """List views for a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching views for {dataset_rid}..."
+        ):
+            views = service.get_views(dataset_rid)
+
+        formatter.format_views(views, format, output)
+
+        if output:
+            formatter.print_success(f"Views information saved to {output}")
+
+    except NotImplementedError as e:
+        formatter.print_warning(f"Feature not available: {e}")
+        raise typer.Exit(0)
+    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 list views: {e}")
+        raise typer.Exit(1)
+
+
+@views_app.command("create")
+def create_view(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    view_name: str = typer.Argument(..., help="View name"),
+    description: Optional[str] = typer.Option(
+        None, "--description", help="View description"
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+):
+    """Create a new view for a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Creating view '{view_name}' for {dataset_rid}..."
+        ):
+            view = service.create_view(dataset_rid, view_name, description)
+
+        formatter.print_success(f"Successfully created view '{view_name}'")
+        formatter.format_view_detail(view, format)
+
+    except NotImplementedError as e:
+        formatter.print_warning(f"Feature not available: {e}")
+        raise typer.Exit(0)
+    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 view: {e}")
+        raise typer.Exit(1)
+
+
+# Add subcommands to main app
+app.add_typer(branches_app, name="branches")
+app.add_typer(files_app, name="files")
+app.add_typer(transactions_app, name="transactions")
+app.add_typer(views_app, name="views")
+
+
 @app.callback()
 def main():
     """

pltr/commands/folder.py

@@ -0,0 +1,338 @@
+"""
+Folder management commands for Foundry filesystem.
+"""
+
+import typer
+from typing import Optional, List
+from rich.console import Console
+from rich.table import Table
+
+from ..services.folder import FolderService
+from ..utils.formatting import OutputFormatter
+from ..utils.progress import SpinnerProgressTracker
+from ..auth.base import ProfileNotFoundError, MissingCredentialsError
+from ..utils.completion import (
+    complete_rid,
+    complete_profile,
+    complete_output_format,
+    cache_rid,
+)
+
+app = typer.Typer()
+console = Console()
+formatter = OutputFormatter(console)
+
+
+@app.command("create")
+def create_folder(
+    name: str = typer.Argument(..., help="Folder display name"),
+    parent_folder: str = typer.Option(
+        "ri.compass.main.folder.0",
+        "--parent-folder",
+        "-p",
+        help="Parent folder RID (default: root folder)",
+        autocompletion=complete_rid,
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+):
+    """Create a new folder in Foundry."""
+    try:
+        service = FolderService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(f"Creating folder '{name}'..."):
+            folder = service.create_folder(
+                display_name=name, parent_folder_rid=parent_folder
+            )
+
+        # Cache the RID for future completions
+        if folder.get("rid"):
+            cache_rid(folder["rid"])
+
+        formatter.print_success(f"Successfully created folder '{name}'")
+        formatter.print_info(f"Folder RID: {folder.get('rid', 'unknown')}")
+
+        # Format output
+        if format == "json":
+            formatter.format_dict(folder)
+        elif format == "csv":
+            formatter.format_list([folder])
+        else:
+            _format_folder_table(folder)
+
+    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 folder: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("get")
+def get_folder(
+    folder_rid: str = typer.Argument(
+        ..., help="Folder Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get detailed information about a specific folder."""
+    try:
+        # Cache the RID for future completions
+        cache_rid(folder_rid)
+
+        service = FolderService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(f"Fetching folder {folder_rid}..."):
+            folder = service.get_folder(folder_rid)
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(folder, output, "json")
+            else:
+                formatter.format_dict(folder)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file([folder], output, "csv")
+            else:
+                formatter.format_list([folder])
+        else:
+            _format_folder_table(folder)
+
+        if output:
+            formatter.print_success(f"Folder 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 folder: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_children(
+    folder_rid: str = typer.Argument(
+        ...,
+        help="Folder Resource Identifier (use 'ri.compass.main.folder.0' for root)",
+        autocompletion=complete_rid,
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+    page_size: Optional[int] = typer.Option(
+        None, "--page-size", help="Number of items per page"
+    ),
+):
+    """List all child resources of a folder."""
+    try:
+        # Cache the RID for future completions
+        cache_rid(folder_rid)
+
+        service = FolderService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Listing children of folder {folder_rid}..."
+        ):
+            children = service.list_children(folder_rid, page_size=page_size)
+
+        if not children:
+            formatter.print_info("No children found in this folder.")
+            return
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(children, output, "json")
+            else:
+                formatter.format_list(children)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file(children, output, "csv")
+            else:
+                formatter.format_list(children)
+        else:
+            _format_children_table(children)
+
+        if output:
+            formatter.print_success(f"Folder children 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 list folder children: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("batch-get")
+def get_folders_batch(
+    folder_rids: List[str] = typer.Argument(
+        ..., help="Folder Resource Identifiers (space-separated)"
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get multiple folders in a single request (max 1000)."""
+    try:
+        service = FolderService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching {len(folder_rids)} folders..."
+        ):
+            folders = service.get_folders_batch(folder_rids)
+
+        # Cache RIDs for future completions
+        for folder in folders:
+            if folder.get("rid"):
+                cache_rid(folder["rid"])
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(folders, output, "json")
+            else:
+                formatter.format_list(folders)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file(folders, output, "csv")
+            else:
+                formatter.format_list(folders)
+        else:
+            _format_folders_batch_table(folders)
+
+        if output:
+            formatter.print_success(f"Folders information saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except ValueError as e:
+        formatter.print_error(f"Invalid request: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to get folders batch: {e}")
+        raise typer.Exit(1)
+
+
+def _format_folder_table(folder: dict):
+    """Format folder information as a table."""
+    table = Table(
+        title="Folder Information", show_header=True, header_style="bold cyan"
+    )
+    table.add_column("Property", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("RID", folder.get("rid", "N/A"))
+    table.add_row("Display Name", folder.get("display_name", "N/A"))
+    table.add_row("Description", folder.get("description", "N/A"))
+    table.add_row("Parent Folder", folder.get("parent_folder_rid", "N/A"))
+    table.add_row("Created", folder.get("created", "N/A"))
+    table.add_row("Modified", folder.get("modified", "N/A"))
+
+    console.print(table)
+
+
+def _format_children_table(children: List[dict]):
+    """Format folder children as a table."""
+    table = Table(title="Folder Children", show_header=True, header_style="bold cyan")
+    table.add_column("Type", style="cyan")
+    table.add_column("Display Name")
+    table.add_column("RID")
+
+    for child in children:
+        table.add_row(
+            child.get("type", "unknown"),
+            child.get("display_name", child.get("name", "N/A")),
+            child.get("rid", "N/A"),
+        )
+
+    console.print(table)
+    console.print(f"\nTotal: {len(children)} items")
+
+
+def _format_folders_batch_table(folders: List[dict]):
+    """Format multiple folders as a table."""
+    table = Table(title="Folders", show_header=True, header_style="bold cyan")
+    table.add_column("Display Name")
+    table.add_column("RID")
+    table.add_column("Parent Folder")
+    table.add_column("Description")
+
+    for folder in folders:
+        table.add_row(
+            folder.get("display_name", "N/A"),
+            folder.get("rid", "N/A"),
+            folder.get("parent_folder_rid", "N/A"),
+            folder.get("description", "N/A") or "",
+        )
+
+    console.print(table)
+    console.print(f"\nTotal: {len(folders)} folders")
+
+
+@app.callback()
+def main():
+    """
+    Folder operations using foundry-platform-sdk.
+
+    Manage folders in the Foundry filesystem. Create, retrieve, and list
+    folder contents using Resource Identifiers (RIDs).
+
+    The root folder RID is: ri.compass.main.folder.0
+
+    Examples:
+        # Create a folder in root
+        pltr folder create "My Folder"
+
+        # Create a folder in a specific parent
+        pltr folder create "Sub Folder" --parent-folder ri.compass.main.folder.xyz123
+
+        # List root folder contents
+        pltr folder list ri.compass.main.folder.0
+
+        # Get folder information
+        pltr folder get ri.compass.main.folder.xyz123
+    """
+    pass