pltr-cli 0.8.0__tar.gz → 0.9.1__tar.gz

{pltr_cli-0.8.0 → pltr_cli-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pltr-cli
-Version: 0.8.0
+Version: 0.9.1
 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.8.0 → pltr_cli-0.9.1}/pyproject.toml

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

{pltr_cli-0.8.0 → pltr_cli-0.9.1}/scripts/release.py

@@ -152,10 +152,25 @@ def check_tag_exists(version):
     return False
 
 
+def update_uv_lock():
+    """Update uv.lock file after version change"""
+    try:
+        subprocess.run(["uv", "lock"], check=True, capture_output=True, text=True)
+        print("Updated uv.lock file")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Error updating uv.lock: {e.stderr}")
+        return False
+    except FileNotFoundError:
+        print("Warning: uv command not found. Skipping uv.lock update.")
+        print("Please ensure uv is installed to keep lock file in sync.")
+        return False
+
+
 def create_release_commit_and_tag(version, release_type, push_mode="ask"):
     """Create release commit and tag"""
     # Stage the version file changes
-    run_git_command("git add pyproject.toml src/pltr/__init__.py")
+    run_git_command("git add pyproject.toml src/pltr/__init__.py uv.lock")
 
     # Create release commit
     commit_message = f"{release_type}: Release version {version}"
@@ -308,9 +323,10 @@ def main():
         print("\nDry run mode - would perform these actions:")
         print(f"1. Update pyproject.toml version to {new_version}")
         print(f"2. Update src/pltr/__init__.py __version__ to {new_version}")
-        print(f"3. Create git commit: '{release_type}: Release version {new_version}'")
-        print(f"4. Create git tag: v{new_version}")
-        print("5. Optionally push to origin")
+        print("3. Update uv.lock file")
+        print(f"4. Create git commit: '{release_type}: Release version {new_version}'")
+        print(f"5. Create git tag: v{new_version}")
+        print("6. Optionally push to origin")
         return
 
     # Check git status
@@ -335,13 +351,14 @@ def main():
     print("This will:")
     print(f"1. Update pyproject.toml version to {new_version}")
     print(f"2. Update src/pltr/__init__.py __version__ to {new_version}")
-    print(f"3. Create git commit and tag v{new_version}")
+    print("3. Update uv.lock file")
+    print(f"4. Create git commit and tag v{new_version}")
     if args.push:
-        print("4. Push to origin to trigger GitHub Actions publishing")
+        print("5. Push to origin to trigger GitHub Actions publishing")
     elif args.no_push:
-        print("4. NOT push to origin (--no-push specified)")
+        print("5. NOT push to origin (--no-push specified)")
     else:
-        print("4. Optionally push to trigger GitHub Actions publishing")
+        print("5. Optionally push to trigger GitHub Actions publishing")
 
     if not args.yes:
         confirm = input("\nProceed with release? (y/N): ").strip().lower()
@@ -362,6 +379,7 @@ def main():
     # Perform release
     update_version_in_pyproject(new_version)
     update_version_in_init_py(new_version)
+    update_uv_lock()  # Update uv.lock with new version
     create_release_commit_and_tag(new_version, release_type, push_mode)
 
     print(f"\n✅ Release {new_version} created successfully!")

pltr_cli-0.9.1/src/pltr/__init__.py

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

{pltr_cli-0.8.0 → pltr_cli-0.9.1}/src/pltr/commands/dataset.py

@@ -93,11 +93,17 @@ def get_schema(
         None, "--output", "-o", help="Output file path"
     ),
 ):
-    """Get the schema of a dataset."""
+    """Get the schema of a dataset (requires API preview access)."""
     try:
         cache_rid(dataset_rid)
         service = DatasetService(profile=profile)
 
+        formatter.print_warning(
+            "Note: This command requires API preview access. "
+            "If you encounter an 'ApiFeaturePreviewUsageOnly' error, "
+            "use 'pltr dataset schema apply' instead to infer/apply schema."
+        )
+
         with SpinnerProgressTracker().track_spinner(
             f"Fetching schema for {dataset_rid}..."
         ):
@@ -120,7 +126,54 @@ def get_schema(
         formatter.print_error(f"Authentication error: {e}")
         raise typer.Exit(1)
     except Exception as e:
-        formatter.print_error(f"Failed to get schema: {e}")
+        if "ApiFeaturePreviewUsageOnly" in str(e):
+            formatter.print_error(
+                "This command requires API preview access. "
+                "Please use 'pltr dataset schema apply' instead."
+            )
+        else:
+            formatter.print_error(f"Failed to get schema: {e}")
+        raise typer.Exit(1)
+
+
+@schema_app.command("apply")
+def apply_schema(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    branch: str = typer.Option("master", "--branch", "-b", help="Dataset branch name"),
+    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,
+    ),
+):
+    """Apply/infer schema for a dataset."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Applying schema to dataset {dataset_rid} on branch '{branch}'..."
+        ):
+            result = service.apply_schema(dataset_rid, branch)
+
+        formatter.print_success(f"Schema applied successfully to branch '{branch}'")
+
+        # Display result if available
+        if result.get("result"):
+            formatter._format_json(result.get("result"))
+
+    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 apply schema: {e}")
         raise typer.Exit(1)
 
 

pltr_cli-0.9.1/src/pltr/services/base.py

@@ -0,0 +1,129 @@
+"""
+Base service class for Foundry API wrappers.
+"""
+
+from typing import Any, Optional, Dict
+from abc import ABC, abstractmethod
+import requests
+
+from ..auth.manager import AuthManager
+from ..auth.storage import CredentialStorage
+from ..config.profiles import ProfileManager
+
+
+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()
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict] = None,
+        json_data: Optional[Dict] = None,
+        headers: Optional[Dict] = None,
+    ) -> requests.Response:
+        """
+        Make a direct HTTP request to Foundry API.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE)
+            endpoint: API endpoint path (e.g., '/foundry-schema-inference/api/...')
+            data: Form data to send
+            json_data: JSON data to send
+            headers: Additional headers
+
+        Returns:
+            Response object
+
+        Raises:
+            requests.HTTPError: If request fails
+        """
+        # Get credentials for authentication
+        storage = CredentialStorage()
+        profile_manager = ProfileManager()
+        profile_name = self.profile or profile_manager.get_active_profile()
+        if not profile_name:
+            from ..auth.base import ProfileNotFoundError
+
+            raise ProfileNotFoundError(
+                "No profile specified and no default profile configured. "
+                "Run 'pltr configure configure' to set up authentication."
+            )
+        credentials = storage.get_profile(profile_name)
+
+        # Build full URL
+        host = credentials.get("host", "").rstrip("/")
+        url = f"{host}{endpoint}"
+
+        # Set up headers with authentication
+        request_headers = {
+            "Authorization": f"Bearer {credentials.get('token')}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        if headers:
+            request_headers.update(headers)
+
+        # Make the request
+        response = requests.request(
+            method=method,
+            url=url,
+            data=data,
+            json=json_data,
+            headers=request_headers,
+        )
+
+        # Raise an error for bad status codes
+        response.raise_for_status()
+
+        return response

{pltr_cli-0.8.0 → pltr_cli-0.9.1}/src/pltr/services/dataset.py

@@ -56,6 +56,61 @@ class DatasetService(BaseService):
         except Exception as e:
             raise RuntimeError(f"Failed to get schema for dataset {dataset_rid}: {e}")
 
+    def apply_schema(self, dataset_rid: str, branch: str = "master") -> Dict[str, Any]:
+        """
+        Apply/infer schema for a dataset using both schema inference and metadata APIs.
+
+        This method performs two sequential API calls:
+        1. Schema inference to infer the dataset schema
+        2. Schema application to apply the inferred schema to the dataset
+
+        Args:
+            dataset_rid: Dataset Resource Identifier
+            branch: Dataset branch name (default: "master")
+
+        Returns:
+            Schema application result including transaction and version information
+        """
+        try:
+            # Step 1: Call schema inference API to infer the schema
+            inference_endpoint = f"/foundry-schema-inference/api/datasets/{dataset_rid}/branches/{branch}/schema"
+            inference_response = self._make_request(
+                "POST", inference_endpoint, json_data={}
+            )
+
+            # Parse the inference response
+            inference_result = (
+                inference_response.json() if inference_response.text else {}
+            )
+
+            # Extract the foundry schema from the inference result
+            foundry_schema = inference_result.get("data", {}).get("foundrySchema")
+            if not foundry_schema:
+                raise RuntimeError(
+                    "Schema inference failed: No foundrySchema found in response"
+                )
+
+            # Step 2: Call foundry-metadata API to apply the schema
+            metadata_endpoint = f"/foundry-metadata/api/schemas/datasets/{dataset_rid}/branches/{branch}"
+            metadata_response = self._make_request(
+                "POST", metadata_endpoint, json_data=foundry_schema
+            )
+
+            # Parse the metadata response
+            metadata_result = metadata_response.json() if metadata_response.text else {}
+
+            return {
+                "dataset_rid": dataset_rid,
+                "branch": branch,
+                "status": "Schema applied successfully",
+                "inference_result": inference_result,
+                "application_result": metadata_result,
+                "transaction_rid": metadata_result.get("transactionRid"),
+                "version_id": metadata_result.get("versionId"),
+            }
+        except Exception as e:
+            raise RuntimeError(f"Failed to apply schema for dataset {dataset_rid}: {e}")
+
     def put_schema(
         self,
         dataset_rid: str,

{pltr_cli-0.8.0 → pltr_cli-0.9.1}/uv.lock

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

pltr_cli-0.8.0/src/pltr/__init__.py

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

pltr_cli-0.8.0/src/pltr/services/base.py

@@ -1,62 +0,0 @@
-"""
-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()