pltr-cli 0.9.3__tar.gz → 0.11.0__tar.gz

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pltr-cli
-Version: 0.9.3
+Version: 0.11.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.9.3 → pltr_cli-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pltr-cli"
-version = "0.9.3"
+version = "0.11.0"
 description = "Command-line interface for Palantir Foundry APIs"
 authors = [
     { name = "anjor", email = "anjor@umd.edu" },

pltr_cli-0.11.0/src/pltr/__init__.py

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

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/src/pltr/commands/folder.py

@@ -279,7 +279,7 @@ def _format_children_table(children: List[dict]):
     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")
+    table.add_column("RID", no_wrap=True)
 
     for child in children:
         table.add_row(
@@ -296,8 +296,8 @@ 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("RID", no_wrap=True)
+    table.add_column("Parent Folder", no_wrap=True)
     table.add_column("Description")
 
     for folder in folders:

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/src/pltr/commands/ontology.py

@@ -366,6 +366,99 @@ def list_linked_objects(
         raise typer.Exit(1)
 
 
+@app.command("object-count")
+def count_objects(
+    ontology_rid: str = typer.Argument(..., help="Ontology Resource Identifier"),
+    object_type: str = typer.Argument(..., help="Object type API name"),
+    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"
+    ),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Count objects of a specific type."""
+    try:
+        service = OntologyObjectService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Counting {object_type} objects..."
+        ):
+            result = service.count_objects(ontology_rid, object_type, branch=branch)
+
+        formatter.format_dict(result, format=format, output=output)
+
+        if output:
+            formatter.print_success(f"Count result 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 count objects: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("object-search")
+def search_objects(
+    ontology_rid: str = typer.Argument(..., help="Ontology Resource Identifier"),
+    object_type: str = typer.Argument(..., help="Object type API name"),
+    query: str = typer.Option(..., "--query", "-q", help="Search query string"),
+    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"
+    ),
+    page_size: Optional[int] = typer.Option(
+        None, "--page-size", help="Number of results per page"
+    ),
+    properties: Optional[str] = typer.Option(
+        None, "--properties", help="Comma-separated list of properties to include"
+    ),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Search objects by query."""
+    try:
+        service = OntologyObjectService(profile=profile)
+
+        prop_list = properties.split(",") if properties else None
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Searching {object_type} objects..."
+        ):
+            objects = service.search_objects(
+                ontology_rid,
+                object_type,
+                query,
+                page_size=page_size,
+                properties=prop_list,
+                branch=branch,
+            )
+
+        if format == "table" and objects:
+            # Use first object's keys as columns
+            columns = list(objects[0].keys()) if objects else []
+            formatter.format_table(
+                objects, columns=columns, format=format, output=output
+            )
+        else:
+            formatter.format_list(objects, format=format, output=output)
+
+        if output:
+            formatter.print_success(f"Search results 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 search objects: {e}")
+        raise typer.Exit(1)
+
+
 # Action commands
 @app.command("action-apply")
 def apply_action(

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/src/pltr/commands/orchestration.py

@@ -92,7 +92,46 @@ def create_build(
         "table", "--format", "-f", help="Output format (table, json, csv)"
     ),
 ):
-    """Create a new build."""
+    """
+    Create a new build with specified target datasets.
+
+    The target parameter must be a JSON object with a 'type' field that specifies
+    the build strategy. Three types are supported:
+
+    \b
+    1. Manual Build - Explicitly specify datasets to build:
+       {
+         "type": "manual",
+         "targetRids": ["ri.foundry.main.dataset.abc123..."]
+       }
+
+    \b
+    2. Upstream Build - Build target datasets and all their upstream dependencies:
+       {
+         "type": "upstream",
+         "targetRids": ["ri.foundry.main.dataset.abc123..."],
+         "ignoredRids": []
+       }
+
+    \b
+    3. Connecting Build - Build datasets between input and target datasets:
+       {
+         "type": "connecting",
+         "inputRids": ["ri.foundry.main.dataset.input123..."],
+         "targetRids": ["ri.foundry.main.dataset.target123..."],
+         "ignoredRids": []
+       }
+
+    Examples:
+
+    \b
+      # Build specific datasets manually
+      pltr orchestration builds create '{"type": "manual", "targetRids": ["ri.foundry.main.dataset.abc123"]}' --branch master
+
+    \b
+      # Build dataset and all upstream dependencies
+      pltr orchestration builds create '{"type": "upstream", "targetRids": ["ri.foundry.main.dataset.abc123"], "ignoredRids": []}' --branch master --force
+    """
     try:
         service = OrchestrationService(profile=profile)
 

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/src/pltr/commands/resource.py

@@ -79,6 +79,64 @@ def get_resource(
         raise typer.Exit(1)
 
 
+@app.command("get-by-path")
+def get_resource_by_path(
+    path: str = typer.Argument(
+        ...,
+        help="Absolute path to the resource (e.g., '/My Organization/Project/Dataset')",
+    ),
+    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 resource by its path."""
+    try:
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching resource at path '{path}'..."
+        ):
+            resource = service.get_resource_by_path(path)
+
+        # Cache the RID for future completions
+        if resource.get("rid"):
+            cache_rid(resource["rid"])
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(resource, output, "json")
+            else:
+                formatter.format_dict(resource)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file([resource], output, "csv")
+            else:
+                formatter.format_list([resource])
+        else:
+            _format_resource_table(resource)
+
+        if output:
+            formatter.print_success(f"Resource 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 resource: {e}")
+        raise typer.Exit(1)
+
+
 @app.command("list")
 def list_resources(
     folder_rid: Optional[str] = typer.Option(
@@ -469,12 +527,15 @@ def main():
 
     Manage resources in the Foundry filesystem. Get resource information,
     search resources, manage metadata, and perform operations using Resource
-    Identifiers (RIDs).
+    Identifiers (RIDs) or paths.
 
     Examples:
-        # Get resource information
+        # Get resource information by RID
         pltr resource get ri.compass.main.dataset.xyz123
 
+        # Get resource information by path
+        pltr resource get-by-path "/My Organization/Project/Dataset Name"
+
         # List all resources
         pltr resource list
 

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/src/pltr/services/dataset.py

@@ -487,18 +487,15 @@ class DatasetService(BaseService):
             # Ensure output directory exists
             output_path.parent.mkdir(parents=True, exist_ok=True)
 
-            file_content = self.service.Dataset.File.read(
+            # Use Dataset.File.content() which returns bytes directly
+            # Note: In SDK v1.27.0, the method is 'content' not 'read'
+            file_content = self.service.Dataset.File.content(
                 dataset_rid=dataset_rid, file_path=file_path, branch_name=branch
             )
 
-            # Write file content to disk
+            # Write file content to disk (file_content is bytes)
             with open(output_path, "wb") as f:
-                if hasattr(file_content, "read"):
-                    # If it's a stream
-                    f.write(file_content.read())
-                else:
-                    # If it's bytes
-                    f.write(file_content)
+                f.write(file_content)
 
             return {
                 "dataset_rid": dataset_rid,

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/src/pltr/services/ontology.py

@@ -287,6 +287,77 @@ class OntologyObjectService(BaseService):
         except Exception as e:
             raise RuntimeError(f"Failed to list linked objects: {e}")
 
+    def count_objects(
+        self,
+        ontology_rid: str,
+        object_type: str,
+        branch: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Count objects of a specific type.
+
+        Args:
+            ontology_rid: Ontology Resource Identifier
+            object_type: Object type API name
+            branch: Branch name (optional)
+
+        Returns:
+            Dictionary containing count information
+        """
+        try:
+            count = self.service.OntologyObject.count(
+                ontology_rid,
+                object_type,
+                branch_name=branch,
+            )
+            return {
+                "ontology_rid": ontology_rid,
+                "object_type": object_type,
+                "count": count,
+                "branch": branch,
+            }
+        except Exception as e:
+            raise RuntimeError(f"Failed to count objects: {e}")
+
+    def search_objects(
+        self,
+        ontology_rid: str,
+        object_type: str,
+        query: str,
+        page_size: Optional[int] = None,
+        properties: Optional[List[str]] = None,
+        branch: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Search objects by query.
+
+        Args:
+            ontology_rid: Ontology Resource Identifier
+            object_type: Object type API name
+            query: Search query string
+            page_size: Number of results per page
+            properties: List of properties to include
+            branch: Branch name (optional)
+
+        Returns:
+            List of matching object dictionaries
+        """
+        try:
+            result = self.service.OntologyObject.search(
+                ontology_rid,
+                object_type,
+                query=query,
+                page_size=page_size,
+                properties=properties,
+                branch_name=branch,
+            )
+            objects = []
+            for obj in result:
+                objects.append(self._format_object(obj))
+            return objects
+        except Exception as e:
+            raise RuntimeError(f"Failed to search objects: {e}")
+
     def _format_object(self, obj: Any) -> Dict[str, Any]:
         """Format object for consistent output."""
         # Objects may have various properties - extract them dynamically

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/src/pltr/services/resource.py

@@ -30,6 +30,22 @@ class ResourceService(BaseService):
         except Exception as e:
             raise RuntimeError(f"Failed to get resource {resource_rid}: {e}")
 
+    def get_resource_by_path(self, path: str) -> Dict[str, Any]:
+        """
+        Get information about a specific resource by its path.
+
+        Args:
+            path: Absolute path to the resource (e.g., "/My Organization/Project/Dataset")
+
+        Returns:
+            Resource information dictionary
+        """
+        try:
+            resource = self.service.Resource.get_by_path(path=path, preview=True)
+            return self._format_resource_info(resource)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get resource at path '{path}': {e}")
+
     def list_resources(
         self,
         folder_rid: Optional[str] = None,

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/src/pltr/utils/formatting.py

@@ -64,7 +64,8 @@ class OutputFormatter:
                 f.write(json_str)
             return None
         else:
-            rich_print(json_str)
+            # Use plain print to ensure valid JSON output without ANSI codes
+            print(json_str)
             return json_str
 
     def _format_csv(
@@ -141,7 +142,11 @@ class OutputFormatter:
 
         # Add columns to table
         for column in columns:
-            table.add_column(column, overflow="fold")
+            # Don't truncate RID columns - they need full visibility
+            if "rid" in column.lower():
+                table.add_column(column, no_wrap=True, overflow="fold")
+            else:
+                table.add_column(column, overflow="fold")
 
         # Add rows
         for item in data:
@@ -424,7 +429,8 @@ class OutputFormatter:
         else:
             # For simple values, just print them
             if format_type == "json":
-                rich_print(json.dumps(data, indent=2, default=str))
+                # Use plain print to ensure valid JSON output without ANSI codes
+                print(json.dumps(data, indent=2, default=str))
             else:
                 rich_print(str(data))
 

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/tests/test_commands/test_ontology.py

@@ -220,6 +220,111 @@ def test_list_linked_objects_command(mock_services):
     mock_instance.list_linked_objects.assert_called_once()
 
 
+def test_count_objects_command(mock_services):
+    """Test count objects command."""
+    mock_instance = Mock()
+    mock_instance.count_objects.return_value = {
+        "ontology_rid": "ri.ontology.main.ontology.test",
+        "object_type": "Employee",
+        "count": 42,
+        "branch": None,
+    }
+    mock_services["object"].return_value = mock_instance
+
+    result = runner.invoke(
+        app, ["object-count", "ri.ontology.main.ontology.test", "Employee"]
+    )
+
+    assert result.exit_code == 0
+    mock_instance.count_objects.assert_called_once_with(
+        "ri.ontology.main.ontology.test", "Employee", branch=None
+    )
+
+
+def test_count_objects_with_branch(mock_services):
+    """Test count objects with branch specified."""
+    mock_instance = Mock()
+    mock_instance.count_objects.return_value = {
+        "ontology_rid": "ri.ontology.main.ontology.test",
+        "object_type": "Employee",
+        "count": 24,
+        "branch": "master",
+    }
+    mock_services["object"].return_value = mock_instance
+
+    result = runner.invoke(
+        app,
+        [
+            "object-count",
+            "ri.ontology.main.ontology.test",
+            "Employee",
+            "--branch",
+            "master",
+        ],
+    )
+
+    assert result.exit_code == 0
+    mock_instance.count_objects.assert_called_once_with(
+        "ri.ontology.main.ontology.test", "Employee", branch="master"
+    )
+
+
+def test_search_objects_command(mock_services):
+    """Test search objects command."""
+    mock_instance = Mock()
+    mock_instance.search_objects.return_value = [
+        {"employee_id": "EMP001", "name": "John Doe"}
+    ]
+    mock_services["object"].return_value = mock_instance
+
+    result = runner.invoke(
+        app,
+        [
+            "object-search",
+            "ri.ontology.main.ontology.test",
+            "Employee",
+            "--query",
+            "John",
+        ],
+    )
+
+    assert result.exit_code == 0
+    mock_instance.search_objects.assert_called_once()
+
+
+def test_search_objects_with_options(mock_services):
+    """Test search objects with all options."""
+    mock_instance = Mock()
+    mock_instance.search_objects.return_value = [
+        {"employee_id": "EMP001", "name": "John Doe"}
+    ]
+    mock_services["object"].return_value = mock_instance
+
+    result = runner.invoke(
+        app,
+        [
+            "object-search",
+            "ri.ontology.main.ontology.test",
+            "Employee",
+            "--query",
+            "Jane",
+            "--page-size",
+            "10",
+            "--properties",
+            "name,department",
+            "--branch",
+            "master",
+        ],
+    )
+
+    assert result.exit_code == 0
+    call_args = mock_instance.search_objects.call_args
+    assert call_args[0] == ("ri.ontology.main.ontology.test", "Employee", "Jane")
+    assert call_args[1]["page_size"] == 10
+    assert call_args[1]["properties"] == ["name", "department"]
+    assert call_args[1]["branch"] == "master"
+
+
 # Action command tests
 def test_apply_action_command(mock_services):
     """Test apply action command."""

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/tests/test_services/test_ontology.py

@@ -335,6 +335,85 @@ def test_list_linked_objects(mock_ontology_object_service, sample_object):
     mock_ontology_object_class.list_linked_objects.assert_called_once()
 
 
+def test_count_objects(mock_ontology_object_service):
+    """Test counting objects."""
+    service, mock_ontology_object_class = mock_ontology_object_service
+    mock_ontology_object_class.count.return_value = 42
+
+    result = service.count_objects("ri.ontology.main.ontology.test", "Employee")
+
+    assert result["count"] == 42
+    assert result["ontology_rid"] == "ri.ontology.main.ontology.test"
+    assert result["object_type"] == "Employee"
+    assert result["branch"] is None
+    mock_ontology_object_class.count.assert_called_once_with(
+        "ri.ontology.main.ontology.test", "Employee", branch_name=None
+    )
+
+
+def test_count_objects_with_branch(mock_ontology_object_service):
+    """Test counting objects with branch specified."""
+    service, mock_ontology_object_class = mock_ontology_object_service
+    mock_ontology_object_class.count.return_value = 24
+
+    result = service.count_objects(
+        "ri.ontology.main.ontology.test", "Employee", branch="master"
+    )
+
+    assert result["count"] == 24
+    assert result["branch"] == "master"
+    mock_ontology_object_class.count.assert_called_once_with(
+        "ri.ontology.main.ontology.test", "Employee", branch_name="master"
+    )
+
+
+def test_search_objects(mock_ontology_object_service, sample_object):
+    """Test searching objects."""
+    service, mock_ontology_object_class = mock_ontology_object_service
+    mock_ontology_object_class.search.return_value = [sample_object]
+
+    result = service.search_objects(
+        "ri.ontology.main.ontology.test", "Employee", "John"
+    )
+
+    assert len(result) == 1
+    assert result[0]["employee_id"] == "EMP001"
+    assert result[0]["name"] == "John Doe"
+    mock_ontology_object_class.search.assert_called_once_with(
+        "ri.ontology.main.ontology.test",
+        "Employee",
+        query="John",
+        page_size=None,
+        properties=None,
+        branch_name=None,
+    )
+
+
+def test_search_objects_with_options(mock_ontology_object_service, sample_object):
+    """Test searching objects with all options."""
+    service, mock_ontology_object_class = mock_ontology_object_service
+    mock_ontology_object_class.search.return_value = [sample_object]
+
+    result = service.search_objects(
+        "ri.ontology.main.ontology.test",
+        "Employee",
+        "Jane",
+        page_size=10,
+        properties=["name", "department"],
+        branch="master",
+    )
+
+    assert len(result) == 1
+    mock_ontology_object_class.search.assert_called_once_with(
+        "ri.ontology.main.ontology.test",
+        "Employee",
+        query="Jane",
+        page_size=10,
+        properties=["name", "department"],
+        branch_name="master",
+    )
+
+
 # ActionService Tests
 def test_apply_action(mock_action_service, sample_action_result):
     """Test applying an action."""

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/tests/test_services/test_resource.py

@@ -66,6 +66,42 @@ class TestResourceService:
         ):
             resource_service.get_resource("ri.compass.main.dataset.123")
 
+    def test_get_resource_by_path(self, resource_service, mock_client):
+        """Test getting a resource by path."""
+        mock_resource = Mock()
+        mock_resource.rid = "ri.compass.main.dataset.123"
+        mock_resource.display_name = "Test Dataset"
+        mock_resource.type = "dataset"
+        mock_resource.path = "/My Organization/Project/Test Dataset"
+
+        mock_client.filesystem.Resource.get_by_path.return_value = mock_resource
+        resource_service._client = mock_client
+
+        result = resource_service.get_resource_by_path(
+            "/My Organization/Project/Test Dataset"
+        )
+
+        mock_client.filesystem.Resource.get_by_path.assert_called_once_with(
+            path="/My Organization/Project/Test Dataset", preview=True
+        )
+        assert result["rid"] == "ri.compass.main.dataset.123"
+        assert result["display_name"] == "Test Dataset"
+        assert result["type"] == "dataset"
+        assert result["path"] == "/My Organization/Project/Test Dataset"
+
+    def test_get_resource_by_path_failure(self, resource_service, mock_client):
+        """Test handling resource get by path failure."""
+        mock_client.filesystem.Resource.get_by_path.side_effect = Exception(
+            "Path not found"
+        )
+        resource_service._client = mock_client
+
+        with pytest.raises(
+            RuntimeError,
+            match="Failed to get resource at path '/Invalid/Path': Path not found",
+        ):
+            resource_service.get_resource_by_path("/Invalid/Path")
+
     def test_list_resources(self, resource_service, mock_client):
         """Test listing resources."""
         mock_resources = [Mock(), Mock()]

{pltr_cli-0.9.3 → pltr_cli-0.11.0}/uv.lock

@@ -710,7 +710,7 @@ wheels = [
 
 [[package]]
 name = "pltr-cli"
-version = "0.9.3"
+version = "0.11.0"
 source = { editable = "." }
 dependencies = [
     { name = "click-repl" },

pltr_cli-0.9.3/src/pltr/__init__.py

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