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

pltr/cli.py

@@ -12,11 +12,13 @@ from pltr.commands import (
     dataset,
     folder,
     ontology,
+    orchestration,
     sql,
     admin,
     shell,
     completion,
     alias,
+    mediasets,
 )
 
 app = typer.Typer(
@@ -31,7 +33,13 @@ 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():
     """