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

pltr/__main__.py

@@ -23,6 +23,9 @@ if "_PLTR_COMPLETE" in os.environ:
 
 # Normal CLI execution
 from pltr.cli import app
+from pltr.utils.alias_resolver import inject_alias_resolution
 
 if __name__ == "__main__":
+    # Resolve aliases before running the app
+    inject_alias_resolution()
     app()

pltr/cli.py

@@ -15,6 +15,7 @@ from pltr.commands import (
     admin,
     shell,
     completion,
+    alias,
 )
 
 app = typer.Typer(
@@ -36,6 +37,7 @@ app.add_typer(
 )
 app.add_typer(shell.shell_app, name="shell", help="Interactive shell mode")
 app.add_typer(completion.app, name="completion", help="Manage shell completions")
+app.add_typer(alias.app, name="alias", help="Manage command aliases")
 
 
 def version_callback(value: bool):

pltr/commands/alias.py

@@ -0,0 +1,241 @@
+"""Command alias management commands."""
+
+import json
+from typing import Optional
+
+import typer
+from rich import print as rprint
+
+from pltr.config.aliases import AliasManager
+from pltr.utils.completion import complete_alias_names
+
+app = typer.Typer(name="alias", help="Manage command aliases", no_args_is_help=True)
+
+
+@app.command()
+def add(
+    name: str = typer.Argument(..., help="Alias name"),
+    command: str = typer.Argument(..., help="Command to alias"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing alias"),
+) -> None:
+    """Create a new command alias."""
+    manager = AliasManager()
+
+    # Check if alias already exists
+    if manager.get_alias(name) and not force:
+        rprint(f"[red]Alias '{name}' already exists. Use --force to overwrite.[/red]")
+        raise typer.Exit(1)
+
+    # Check for reserved command names
+    reserved_commands = [
+        "configure",
+        "verify",
+        "dataset",
+        "ontology",
+        "sql",
+        "admin",
+        "shell",
+        "completion",
+        "alias",
+        "help",
+        "--version",
+    ]
+    if name in reserved_commands:
+        rprint(f"[red]Cannot use reserved command name '{name}' as alias[/red]")
+        raise typer.Exit(1)
+
+    try:
+        if force and manager.get_alias(name):
+            success = manager.edit_alias(name, command)
+            action = "Updated"
+        else:
+            success = manager.add_alias(name, command)
+            action = "Created"
+
+        if success:
+            rprint(f"[green]{action} alias:[/green] {name} → {command}")
+        else:
+            rprint(f"[red]Failed to create alias '{name}'[/red]")
+            raise typer.Exit(1)
+    except ValueError as e:
+        rprint(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def remove(
+    name: str = typer.Argument(
+        ..., help="Alias name to remove", autocompletion=complete_alias_names
+    ),
+    confirm: bool = typer.Option(
+        True, "--confirm/--no-confirm", help="Confirm removal"
+    ),
+) -> None:
+    """Remove a command alias."""
+    manager = AliasManager()
+
+    command = manager.get_alias(name)
+    if not command:
+        rprint(f"[red]Alias '{name}' not found[/red]")
+        raise typer.Exit(1)
+
+    if confirm:
+        confirmation = typer.confirm(f"Remove alias '{name}' → {command}?")
+        if not confirmation:
+            rprint("[yellow]Removal cancelled[/yellow]")
+            return
+
+    if manager.remove_alias(name):
+        rprint(f"[green]Removed alias '{name}'[/green]")
+    else:
+        rprint(f"[red]Failed to remove alias '{name}'[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def edit(
+    name: str = typer.Argument(
+        ..., help="Alias name to edit", autocompletion=complete_alias_names
+    ),
+    command: str = typer.Argument(..., help="New command for the alias"),
+) -> None:
+    """Edit an existing command alias."""
+    manager = AliasManager()
+
+    if not manager.get_alias(name):
+        rprint(f"[red]Alias '{name}' not found[/red]")
+        raise typer.Exit(1)
+
+    try:
+        if manager.edit_alias(name, command):
+            rprint(f"[green]Updated alias:[/green] {name} → {command}")
+        else:
+            rprint(f"[red]Failed to edit alias '{name}'[/red]")
+            raise typer.Exit(1)
+    except ValueError as e:
+        rprint(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_aliases() -> None:
+    """List all command aliases."""
+    manager = AliasManager()
+    manager.display_aliases()
+
+
+@app.command()
+def show(
+    name: str = typer.Argument(
+        ..., help="Alias name to show", autocompletion=complete_alias_names
+    ),
+) -> None:
+    """Show details of a specific alias."""
+    manager = AliasManager()
+    manager.display_aliases(name)
+
+
+@app.command()
+def clear(
+    confirm: bool = typer.Option(
+        True, "--confirm/--no-confirm", help="Confirm clearing all aliases"
+    ),
+) -> None:
+    """Clear all command aliases."""
+    manager = AliasManager()
+
+    aliases = manager.list_aliases()
+    if not aliases:
+        rprint("[yellow]No aliases to clear[/yellow]")
+        return
+
+    if confirm:
+        confirmation = typer.confirm(f"Clear all {len(aliases)} aliases?")
+        if not confirmation:
+            rprint("[yellow]Clear cancelled[/yellow]")
+            return
+
+    count = manager.clear_all()
+    rprint(f"[green]Cleared {count} aliases[/green]")
+
+
+@app.command("export")
+def export_aliases(
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file (default: stdout)"
+    ),
+) -> None:
+    """Export aliases to JSON format."""
+    manager = AliasManager()
+    aliases = manager.export_aliases()
+
+    if not aliases:
+        rprint("[yellow]No aliases to export[/yellow]")
+        return
+
+    json_data = json.dumps(aliases, indent=2, sort_keys=True)
+
+    if output:
+        with open(output, "w") as f:
+            f.write(json_data)
+        rprint(f"[green]Exported {len(aliases)} aliases to {output}[/green]")
+    else:
+        print(json_data)
+
+
+@app.command("import")
+def import_aliases(
+    input_file: str = typer.Argument(..., help="JSON file containing aliases"),
+    merge: bool = typer.Option(
+        False, "--merge", "-m", help="Merge with existing aliases (default: replace)"
+    ),
+) -> None:
+    """Import aliases from a JSON file."""
+    manager = AliasManager()
+
+    try:
+        with open(input_file, "r") as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, IOError) as e:
+        rprint(f"[red]Error reading file: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not isinstance(data, dict):
+        rprint("[red]Invalid format: expected JSON object with alias mappings[/red]")
+        raise typer.Exit(1)
+
+    # Clear existing aliases if not merging
+    if not merge and manager.list_aliases():
+        confirmation = typer.confirm("Replace existing aliases?")
+        if not confirmation:
+            rprint("[yellow]Import cancelled[/yellow]")
+            return
+        manager.clear_all()
+
+    count = manager.import_aliases(data)
+    rprint(f"[green]Imported {count} aliases from {input_file}[/green]")
+
+
+@app.command()
+def resolve(
+    command: str = typer.Argument(
+        ..., help="Command to resolve", autocompletion=complete_alias_names
+    ),
+) -> None:
+    """Resolve an alias to show the actual command."""
+    manager = AliasManager()
+
+    resolved = manager.resolve_alias(command)
+    if resolved == command:
+        if command in manager.list_aliases():
+            rprint(
+                f"[yellow]'{command}' is an alias but may have circular references[/yellow]"
+            )
+        else:
+            rprint(f"[yellow]'{command}' is not an alias[/yellow]")
+    else:
+        rprint(f"[green]{command}[/green] → {resolved}")
+
+
+if __name__ == "__main__":
+    app()

pltr/commands/ontology.py

@@ -33,16 +33,13 @@ def list_ontologies(
     output: Optional[str] = typer.Option(
         None, "--output", "-o", help="Output file path"
     ),
-    page_size: Optional[int] = typer.Option(
-        None, "--page-size", help="Number of results per page"
-    ),
 ):
     """List all available ontologies."""
     try:
         service = OntologyService(profile=profile)
 
         with SpinnerProgressTracker().track_spinner("Fetching ontologies..."):
-            ontologies = service.list_ontologies(page_size=page_size)
+            ontologies = service.list_ontologies()
 
         formatter.format_table(
             ontologies,
@@ -106,16 +103,13 @@ def list_object_types(
     output: Optional[str] = typer.Option(
         None, "--output", "-o", help="Output file path"
     ),
-    page_size: Optional[int] = typer.Option(
-        None, "--page-size", help="Number of results per page"
-    ),
 ):
     """List object types in an ontology."""
     try:
         service = ObjectTypeService(profile=profile)
 
         with SpinnerProgressTracker().track_spinner("Fetching object types..."):
-            object_types = service.list_object_types(ontology_rid, page_size=page_size)
+            object_types = service.list_object_types(ontology_rid)
 
         formatter.format_table(
             object_types,

pltr/config/aliases.py

@@ -0,0 +1,254 @@
+"""Alias configuration management for pltr-cli."""
+
+import json
+from typing import Dict, List, Optional
+
+from rich import print as rprint
+from rich.table import Table
+
+from pltr.config.settings import Settings
+
+
+class AliasManager:
+    """Manages command aliases for pltr-cli."""
+
+    def __init__(self) -> None:
+        """Initialize the alias manager."""
+        settings = Settings()
+        self.config_dir = settings.config_dir
+        self.aliases_file = self.config_dir / "aliases.json"
+        self.aliases = self._load_aliases()
+
+    def _load_aliases(self) -> Dict[str, str]:
+        """Load aliases from the configuration file.
+
+        Returns:
+            Dictionary mapping alias names to commands
+        """
+        if not self.aliases_file.exists():
+            return {}
+
+        try:
+            with open(self.aliases_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    def _save_aliases(self) -> None:
+        """Save aliases to the configuration file."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        with open(self.aliases_file, "w") as f:
+            json.dump(self.aliases, f, indent=2, sort_keys=True)
+
+    def add_alias(self, name: str, command: str) -> bool:
+        """Add a new alias.
+
+        Args:
+            name: Alias name
+            command: Command to alias
+
+        Returns:
+            True if alias was added, False if it already exists
+
+        Raises:
+            ValueError: If the alias would create a circular reference
+        """
+        if name in self.aliases:
+            return False
+
+        # Check for circular references
+        if self._would_create_cycle(name, command):
+            raise ValueError(f"Alias '{name}' would create a circular reference")
+
+        self.aliases[name] = command
+        self._save_aliases()
+        return True
+
+    def remove_alias(self, name: str) -> bool:
+        """Remove an alias.
+
+        Args:
+            name: Alias name to remove
+
+        Returns:
+            True if alias was removed, False if it didn't exist
+        """
+        if name not in self.aliases:
+            return False
+
+        del self.aliases[name]
+        self._save_aliases()
+        return True
+
+    def edit_alias(self, name: str, command: str) -> bool:
+        """Edit an existing alias.
+
+        Args:
+            name: Alias name to edit
+            command: New command for the alias
+
+        Returns:
+            True if alias was edited, False if it doesn't exist
+        """
+        if name not in self.aliases:
+            return False
+
+        # Check for circular references
+        if self._would_create_cycle(name, command):
+            raise ValueError(f"Alias '{name}' would create a circular reference")
+
+        self.aliases[name] = command
+        self._save_aliases()
+        return True
+
+    def get_alias(self, name: str) -> Optional[str]:
+        """Get the command for an alias.
+
+        Args:
+            name: Alias name
+
+        Returns:
+            The aliased command, or None if alias doesn't exist
+        """
+        return self.aliases.get(name)
+
+    def list_aliases(self) -> Dict[str, str]:
+        """Get all aliases.
+
+        Returns:
+            Dictionary of all aliases
+        """
+        return self.aliases.copy()
+
+    def resolve_alias(self, command: str, max_depth: int = 10) -> str:
+        """Resolve an alias to its final command.
+
+        Args:
+            command: Command that might be an alias
+            max_depth: Maximum recursion depth for nested aliases
+
+        Returns:
+            The resolved command
+        """
+        resolved = command
+        depth = 0
+        seen = set()
+
+        while resolved in self.aliases and depth < max_depth:
+            if resolved in seen:
+                # Circular reference detected
+                return command
+
+            seen.add(resolved)
+            resolved = self.aliases[resolved]
+            depth += 1
+
+        return resolved
+
+    def _would_create_cycle(self, name: str, command: str) -> bool:
+        """Check if adding/editing an alias would create a cycle.
+
+        Args:
+            name: Alias name
+            command: Command to check
+
+        Returns:
+            True if this would create a cycle
+        """
+        # Direct self-reference
+        if command == name:
+            return True
+
+        # Follow the chain starting from command
+        # If we ever reach 'name', it would create a cycle
+        current = command
+        visited = set()
+
+        while current in self.aliases:
+            # Check for existing cycles
+            if current in visited:
+                break
+            visited.add(current)
+
+            # Get what this alias points to
+            current = self.aliases[current]
+
+            # If we reached the name we're trying to add, it's a cycle
+            if current == name:
+                return True
+
+        return False
+
+    def display_aliases(self, name: Optional[str] = None) -> None:
+        """Display aliases in a formatted table.
+
+        Args:
+            name: Optional specific alias to display
+        """
+        if name:
+            command = self.get_alias(name)
+            if command:
+                rprint(f"[green]{name}[/green] → {command}")
+            else:
+                rprint(f"[red]Alias '{name}' not found[/red]")
+            return
+
+        if not self.aliases:
+            rprint("[yellow]No aliases configured[/yellow]")
+            return
+
+        table = Table(title="Command Aliases", show_header=True)
+        table.add_column("Alias", style="cyan")
+        table.add_column("Command", style="green")
+
+        for alias_name, command in sorted(self.aliases.items()):
+            table.add_row(alias_name, command)
+
+        rprint(table)
+
+    def get_completion_items(self) -> List[str]:
+        """Get alias names for shell completion.
+
+        Returns:
+            List of alias names
+        """
+        return list(self.aliases.keys())
+
+    def clear_all(self) -> int:
+        """Clear all aliases.
+
+        Returns:
+            Number of aliases cleared
+        """
+        count = len(self.aliases)
+        self.aliases = {}
+        self._save_aliases()
+        return count
+
+    def import_aliases(self, data: Dict[str, str]) -> int:
+        """Import aliases from a dictionary.
+
+        Args:
+            data: Dictionary of aliases to import
+
+        Returns:
+            Number of aliases imported
+        """
+        count = 0
+        for name, command in data.items():
+            if not self._would_create_cycle(name, command):
+                self.aliases[name] = command
+                count += 1
+
+        if count > 0:
+            self._save_aliases()
+
+        return count
+
+    def export_aliases(self) -> Dict[str, str]:
+        """Export all aliases.
+
+        Returns:
+            Dictionary of all aliases
+        """
+        return self.aliases.copy()

pltr/services/ontology.py

@@ -13,20 +13,18 @@ class OntologyService(BaseService):
         """Get the Foundry ontologies service."""
         return self.client.ontologies
 
-    def list_ontologies(self, page_size: Optional[int] = None) -> List[Dict[str, Any]]:
+    def list_ontologies(self) -> List[Dict[str, Any]]:
         """
         List all ontologies visible to the current user.
 
-        Args:
-            page_size: Number of results per page
-
         Returns:
             List of ontology information dictionaries
         """
         try:
-            result = self.service.Ontology.list(page_size=page_size)
+            result = self.service.Ontology.list()
             ontologies = []
-            for ontology in result:
+            # The response has a 'data' field containing the list of ontologies
+            for ontology in result.data:
                 ontologies.append(self._format_ontology_info(ontology))
             return ontologies
         except Exception as e:
@@ -65,23 +63,22 @@ class ObjectTypeService(BaseService):
         """Get the Foundry ontologies service."""
         return self.client.ontologies
 
-    def list_object_types(
-        self, ontology_rid: str, page_size: Optional[int] = None
-    ) -> List[Dict[str, Any]]:
+    def list_object_types(self, ontology_rid: str) -> List[Dict[str, Any]]:
         """
         List object types in an ontology.
 
         Args:
             ontology_rid: Ontology Resource Identifier
-            page_size: Number of results per page
 
         Returns:
             List of object type information dictionaries
         """
         try:
-            result = self.service.ObjectType.list(ontology_rid, page_size=page_size)
+            # ObjectType is nested under Ontology in the SDK
+            result = self.service.Ontology.ObjectType.list(ontology_rid)
             object_types = []
-            for obj_type in result:
+            # The response has a 'data' field containing the list of object types
+            for obj_type in result.data:
                 object_types.append(self._format_object_type_info(obj_type))
             return object_types
         except Exception as e:
@@ -99,13 +96,14 @@ class ObjectTypeService(BaseService):
             Object type information dictionary
         """
         try:
-            obj_type = self.service.ObjectType.get(ontology_rid, object_type)
+            # ObjectType is nested under Ontology in the SDK
+            obj_type = self.service.Ontology.ObjectType.get(ontology_rid, object_type)
             return self._format_object_type_info(obj_type)
         except Exception as e:
             raise RuntimeError(f"Failed to get object type {object_type}: {e}")
 
     def list_outgoing_link_types(
-        self, ontology_rid: str, object_type: str, page_size: Optional[int] = None
+        self, ontology_rid: str, object_type: str
     ) -> List[Dict[str, Any]]:
         """
         List outgoing link types for an object type.
@@ -113,17 +111,18 @@ class ObjectTypeService(BaseService):
         Args:
             ontology_rid: Ontology Resource Identifier
             object_type: Object type API name
-            page_size: Number of results per page
 
         Returns:
             List of link type information dictionaries
         """
         try:
-            result = self.service.ObjectType.list_outgoing_link_types(
-                ontology_rid, object_type, page_size=page_size
+            # ObjectType is nested under Ontology in the SDK
+            result = self.service.Ontology.ObjectType.list_outgoing_link_types(
+                ontology_rid, object_type
             )
             link_types = []
-            for link_type in result:
+            # The response has a 'data' field containing the list of link types
+            for link_type in result.data:
                 link_types.append(self._format_link_type_info(link_type))
             return link_types
         except Exception as e:

pltr/utils/alias_resolver.py

@@ -0,0 +1,56 @@
+"""Alias resolution utilities for CLI commands."""
+
+import shlex
+import sys
+from typing import List, Optional
+
+from pltr.config.aliases import AliasManager
+
+
+def resolve_command_aliases(args: Optional[List[str]] = None) -> List[str]:
+    """Resolve command aliases in the argument list.
+
+    Args:
+        args: Command arguments (defaults to sys.argv[1:])
+
+    Returns:
+        Resolved command arguments
+    """
+    if args is None:
+        args = sys.argv[1:]
+
+    if not args:
+        return args
+
+    # Don't resolve aliases for certain commands
+    if args[0] in ["alias", "--help", "-h", "--version", "completion"]:
+        return args
+
+    # Check if the first argument is an alias
+    manager = AliasManager()
+    first_arg = args[0]
+
+    # Try to resolve as an alias
+    resolved = manager.resolve_alias(first_arg)
+
+    if resolved != first_arg:
+        # It's an alias - parse the resolved command
+        try:
+            resolved_parts = shlex.split(resolved)
+            # Replace the first argument with the resolved command parts
+            # and append any additional arguments
+            return resolved_parts + args[1:]
+        except ValueError:
+            # If parsing fails, return original args
+            return args
+
+    return args
+
+
+def inject_alias_resolution() -> None:
+    """Inject alias resolution into sys.argv before CLI parsing."""
+    # Get resolved arguments
+    resolved_args = resolve_command_aliases()
+
+    # Replace sys.argv with resolved arguments
+    sys.argv = [sys.argv[0]] + resolved_args

pltr/utils/completion.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import json
 
 from pltr.config.profiles import ProfileManager
+from pltr.config.aliases import AliasManager
 
 
 def get_cached_rids() -> List[str]:
@@ -111,6 +112,13 @@ def complete_ontology_action(incomplete: str):
     return [action for action in actions if action.startswith(incomplete)]
 
 
+def complete_alias_names(incomplete: str):
+    """Complete alias names."""
+    manager = AliasManager()
+    aliases = manager.get_completion_items()
+    return [alias for alias in aliases if alias.startswith(incomplete)]
+
+
 def complete_file_path(incomplete: str):
     """Complete file paths."""
     # This is handled by shell natively, but we can provide hints

{pltr_cli-0.2.0.dist-info → pltr_cli-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pltr-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Command-line interface for Palantir Foundry APIs
 Project-URL: Homepage, https://github.com/anjor/pltr-cli
 Project-URL: Repository, https://github.com/anjor/pltr-cli

{pltr_cli-0.2.0.dist-info → pltr_cli-0.3.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pltr/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
-pltr/__main__.py,sha256=PQIEddxNh3RNfW-pW0DFDgH2r_RptnKvgBcF9N4S5ik,742
-pltr/cli.py,sha256=lJU7EMPjHkaehA32CJh3d6zUNF8iEGHqGX-K45ErqhU,1798
+pltr/__main__.py,sha256=HWJ49UoAYBQCf8kjuySPmBTuUjTZrOx-y6PzMTyS1KE,879
+pltr/cli.py,sha256=Kb9237LDITTX1VU-X-O5eKn8dXKI0R28HokYXGGklNU,1879
 pltr/auth/__init__.py,sha256=G0V-Rh25FaJsH2nhrf146XQQG_ApdbyPJNuHJC25kgk,38
 pltr/auth/base.py,sha256=LvmCwS7A0q0CITcym8udPzdACL52_jSGusiaeCTOaE8,981
 pltr/auth/manager.py,sha256=ZqlGefr1a8MGx0g7kkQhpmiuVp0XTg3f43yMBCk-IRo,4305
@@ -9,14 +9,16 @@ pltr/auth/storage.py,sha256=C7I3-22CJcnrKGNdxk9nXjphsnqQVguT5gNfAnR78Ok,2474
 pltr/auth/token.py,sha256=V48kxGn7CFbNGo17er5oI_ZA3xJ3iS9TsFjphZYqS2s,1925
 pltr/commands/__init__.py,sha256=iOLJ1ql4mz-3-4nz21hAqjd-9IjpYAIxr9SJQKHNFxM,29
 pltr/commands/admin.py,sha256=foscSO-QuH6uggUR5Rmv9pTqGjEXTUzpmMFj2-8hEJs,17065
+pltr/commands/alias.py,sha256=r9xMsQNrGvaixSlspzoO2IXQ44LFXuZM4itt8vC0dRc,6862
 pltr/commands/completion.py,sha256=YTxaRL4-rDs5n7aXf3ogFsxbHVJUBo_HiBbd0fbBPZ0,10870
 pltr/commands/configure.py,sha256=oYj-VlOEj3MDwtB2RC4bYOYzI_sXTanPnz7y1GmMTqY,4800
 pltr/commands/dataset.py,sha256=BCYfaBpLji5wasOiH_jOqO-JC9ScfJhodox9kl9W2Cw,3609
-pltr/commands/ontology.py,sha256=3MwGsRgCzOsG5OTo0xu1iNa3tpZy64e_Fy3O8I45_5I,18587
+pltr/commands/ontology.py,sha256=zUgSrmv8xi26SQK7GsM3qusgR9Wuka0GyzE7L8DkduE,18317
 pltr/commands/shell.py,sha256=QLF7TEGpaau9i0A9s3VjnegvtHde-SLRqI4suJFT4WI,3622
 pltr/commands/sql.py,sha256=wol0Rlvi_RplCFbOg4LCa3VXsOqmRZdFFVv7V6iVkh8,12602
 pltr/commands/verify.py,sha256=n8LWhbfGieYa-a5_l3MxqkYbdpyVf8-i0FQIL__AaPA,6650
 pltr/config/__init__.py,sha256=Y6gARy5lUHy-OJaOUxtfXoeQVNZV5QHLl6uKHQ8tpTk,41
+pltr/config/aliases.py,sha256=ZmesZWMfa5riZlVe3fyC7EI3uIzxEGsDHz-8shOpIbM,6947
 pltr/config/profiles.py,sha256=XMUIp6Ez5LNC6rGXZe2JLH7IKepXhARtuc8ASUA9FYA,3431
 pltr/config/settings.py,sha256=bfIiosPqH_W73TOHS71DvgZdAHka4fJDopU1SvBRFuQ,2908
 pltr/services/__init__.py,sha256=zQpgrqPdAkZI-nobi33mctU2-iGNgazzvjBVY8YRbSQ,101
@@ -25,14 +27,15 @@ pltr/services/base.py,sha256=R2G781FI-sXtjUyLd91bVnmLb4cYZI3G8U5ndR9NLA4,1593
 pltr/services/dataset.py,sha256=W3zoh-9YIJ6HBsDijejVEngKvpudFoZinYtHDmAXCOc,2785
 pltr/services/dataset_full.py,sha256=FyMiwOSyX1cUrYXaK0T_1iq5G_X0e5iZTibJHuEmMeE,9869
 pltr/services/dataset_v2.py,sha256=_uhcVJ91w_Y07glceqHceccAwPWr6q1TWSIqcP1FU8I,4259
-pltr/services/ontology.py,sha256=d5MD0QeLfqs6W_XdteiK1da0yo_TKSftBmEOfPiLvf8,14755
+pltr/services/ontology.py,sha256=iW7qRK8ptlw-u4eAwLNC-mdzLoLZzh7SRqJyok2c3GU,14883
 pltr/services/sql.py,sha256=19cscjlzN8WE1s8_ctiRcrOvMzCfmWRj49vjJ8Gs5Q4,11286
 pltr/utils/__init__.py,sha256=DF7TigL1XbKVGM5VjgU8_8AGIszofkdO80oCzLGGnTE,38
-pltr/utils/completion.py,sha256=QdTkpT9MMs7C7keuJi79sMLerFX3CarpB4FrCKImjSc,4712
+pltr/utils/alias_resolver.py,sha256=DIF7P1UnUU8kqocJfIDEWjYq4s8_0KfqRZBbECeZEh8,1539
+pltr/utils/completion.py,sha256=bjeqjleEfB2YcQFpcxvF0GoQ763F6KBbULSZC4FWY_g,4980
 pltr/utils/formatting.py,sha256=Ptv7obiB7uWNf5YTiY4rUAKmabO5UGnwLocSfLplrZ0,18552
 pltr/utils/progress.py,sha256=BKYbiLO61uhQbibabU7pxvvbAWMRLRmqk4pZldBQK_g,9053
-pltr_cli-0.2.0.dist-info/METADATA,sha256=xk4xxyxl6TXmvgvrcfkR91E-TgnJiA4FdDY6ElW434Y,8864
-pltr_cli-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pltr_cli-0.2.0.dist-info/entry_points.txt,sha256=8tvEcW04kA_oAE2Dwwu-Og9efjl4ESJvs4AzlP2KBdQ,38
-pltr_cli-0.2.0.dist-info/licenses/LICENSE,sha256=6VUFd_ytnOBD2O1tmkKrA-smigi9QEhYr_tge4h4z8Y,1070
-pltr_cli-0.2.0.dist-info/RECORD,,
+pltr_cli-0.3.0.dist-info/METADATA,sha256=BVT_zd9ZrK811JeMXPR_IX1S3-ahE3lhk6q2QiNdbFA,8864
+pltr_cli-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pltr_cli-0.3.0.dist-info/entry_points.txt,sha256=8tvEcW04kA_oAE2Dwwu-Og9efjl4ESJvs4AzlP2KBdQ,38
+pltr_cli-0.3.0.dist-info/licenses/LICENSE,sha256=6VUFd_ytnOBD2O1tmkKrA-smigi9QEhYr_tge4h4z8Y,1070
+pltr_cli-0.3.0.dist-info/RECORD,,