pltr-cli 0.14.1__tar.gz → 0.15.0__tar.gz

{pltr_cli-0.14.1 → pltr_cli-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pltr-cli
-Version: 0.14.1
+Version: 0.15.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
@@ -30,6 +30,7 @@ Requires-Dist: click-repl>=0.3.0
 Requires-Dist: foundry-platform-sdk<2.0.0,>=1.69.0
 Requires-Dist: keyring>=25.6.0
 Requires-Dist: pandas>=2.0.0
+Requires-Dist: pyarrow>=15.0.0
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: requests>=2.32.4
 Requires-Dist: rich>=14.1.0

{pltr_cli-0.14.1 → pltr_cli-0.15.0}/mypy.ini

@@ -10,3 +10,7 @@ disallow_untyped_decorators = False
 # Ignore missing imports for foundry SDK
 [mypy-foundry.*]
 ignore_missing_imports = True
+
+# pyarrow ships no py.typed marker
+[mypy-pyarrow.*]
+ignore_missing_imports = True

{pltr_cli-0.14.1 → pltr_cli-0.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pltr-cli"
-version = "0.14.1"
+version = "0.15.0"
 description = "Command-line interface for Palantir Foundry APIs"
 authors = [
     { name = "anjor", email = "anjor@umd.edu" },
@@ -12,6 +12,7 @@ dependencies = [
     "foundry-platform-sdk>=1.69.0,<2.0.0",
     "keyring>=25.6.0",
     "pandas>=2.0.0",
+    "pyarrow>=15.0.0",
     "python-dotenv>=1.1.1",
     "requests>=2.32.4",
     "rich>=14.1.0",

pltr_cli-0.15.0/src/pltr/__init__.py

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

{pltr_cli-0.14.1 → pltr_cli-0.15.0}/src/pltr/commands/language_models.py

@@ -123,6 +123,148 @@ def display_openai_response(response: dict, format: str, output: Optional[str]):
         formatter.display(response, format)
 
 
+# ===== Shared Language Model Commands =====
+
+
+@app.command("list")
+def list_models(
+    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 available language models for the current enrollment."""
+    try:
+        from ..services.language_models import LanguageModelsService
+
+        service = LanguageModelsService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner("Fetching available models..."):
+            models = service.list_available_models()
+
+        formatter.format_table(
+            models,
+            columns=["model_rid", "status", "type", "display_name"],
+            format=format,
+            output=output,
+        )
+
+        if output:
+            formatter.print_success(f"Model list 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"Operation failed: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("status")
+def model_status(
+    model_id: str = typer.Argument(
+        ...,
+        help="Model Resource Identifier (ri.language-model-service..language-model.<id>)",
+    ),
+    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"
+    ),
+):
+    """Check enrollment status for a language model via direct API fallback endpoints."""
+    try:
+        from ..services.language_models import LanguageModelsService
+
+        service = LanguageModelsService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner("Checking model status..."):
+            result = service.get_model_enrollment_status(model_id)
+
+        formatter.format_dict(result, format=format, output=output)
+
+        if output:
+            formatter.print_success(f"Model status 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"Operation failed: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("enroll")
+def enroll_model(
+    model_id: str = typer.Argument(
+        ...,
+        help="Model Resource Identifier (ri.language-model-service..language-model.<id>)",
+    ),
+    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"
+    ),
+):
+    """Enroll/enable a language model via direct API fallback endpoints."""
+    try:
+        from ..services.language_models import LanguageModelsService
+
+        service = LanguageModelsService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner("Enrolling model..."):
+            result = service.enroll_model(model_id)
+
+        formatter.format_dict(result, format=format, output=output)
+
+        if output:
+            formatter.print_success(f"Enrollment 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"Operation failed: {e}")
+        raise typer.Exit(1)
+
+
 # ===== Anthropic Commands =====
 
 
@@ -323,9 +465,9 @@ def anthropic_messages_advanced(
         # conversation.json:
         # {
         #   "messages": [
-        #     {"role": "user", "content": [{"type": "text", "text": "Hi"}]},
-        #     {"role": "assistant", "content": [{"type": "text", "text": "Hello!"}]},
-        #     {"role": "user", "content": [{"type": "text", "text": "Help me"}]}
+        #     {"role": "USER", "content": [{"type": "text", "text": "Hi"}]},
+        #     {"role": "ASSISTANT", "content": [{"type": "text", "text": "Hello!"}]},
+        #     {"role": "USER", "content": [{"type": "text", "text": "Help me"}]}
         #   ],
         #   "maxTokens": 500
         # }
@@ -334,11 +476,11 @@ def anthropic_messages_advanced(
 
         # Inline JSON with system prompt
         pltr language-models anthropic messages-advanced ri.language-models.main.model.abc123 \\
-            --request '{"messages": [{"role": "user", "content": [{"type": "text", "text": "Hi"}]}], "maxTokens": 100, "system": [{"type": "text", "text": "Be concise"}]}'
+            --request '{"messages": [{"role": "USER", "content": [{"type": "text", "text": "Hi"}]}], "maxTokens": 100, "system": [{"type": "text", "text": "Be concise"}]}'
 
         # With extended thinking
         pltr language-models anthropic messages-advanced ri.language-models.main.model.abc123 \\
-            --request '{"messages": [{"role": "user", "content": [{"type": "text", "text": "Solve this problem"}]}], "maxTokens": 2000, "thinking": {"type": "enabled", "budget": 10000}}'
+            --request '{"messages": [{"role": "USER", "content": [{"type": "text", "text": "Solve this problem"}]}], "maxTokens": 2000, "thinking": {"type": "enabled", "budget": 10000}}'
     """
     try:
         # Parse request JSON

{pltr_cli-0.14.1 → pltr_cli-0.15.0}/src/pltr/commands/ontology.py

@@ -164,6 +164,112 @@ def get_object_type(
         raise typer.Exit(1)
 
 
+@app.command("object-type-create")
+def create_object_type(
+    ontology_rid: str = typer.Argument(..., help="Ontology Resource Identifier"),
+    api_name: str = typer.Option(..., "--api-name", help="Object type API name"),
+    display_name: str = typer.Option(
+        ..., "--display-name", help="Object type display name"
+    ),
+    primary_key: str = typer.Option(
+        ..., "--primary-key", help="Primary key property API name"
+    ),
+    backing_dataset: str = typer.Option(
+        ..., "--backing-dataset", help="Backing dataset RID"
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--description", help="Object type description"
+    ),
+    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"
+    ),
+):
+    """Create a new object type in an ontology."""
+    try:
+        service = ObjectTypeService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Creating object type {api_name}..."
+        ):
+            result = service.create_object_type(
+                ontology_rid=ontology_rid,
+                api_name=api_name,
+                display_name=display_name,
+                primary_key=primary_key,
+                backing_dataset=backing_dataset,
+                description=description,
+            )
+
+        formatter.format_dict(result, format=format, output=output)
+
+        if output:
+            formatter.print_success(f"Object type creation 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 create object type: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("link-type-create")
+def create_link_type(
+    ontology_rid: str = typer.Argument(..., help="Ontology Resource Identifier"),
+    api_name: str = typer.Option(..., "--api-name", help="Link type API name"),
+    from_object: str = typer.Option(..., "--from", help="Source object type API name"),
+    to_object: str = typer.Option(..., "--to", help="Target object type API name"),
+    display_name: Optional[str] = typer.Option(
+        None, "--display-name", help="Link type display name"
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--description", help="Link type description"
+    ),
+    reverse_api_name: Optional[str] = typer.Option(
+        None, "--reverse-api-name", help="Reverse direction link 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"
+    ),
+):
+    """Create a new link type in an ontology."""
+    try:
+        service = ObjectTypeService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Creating link type {api_name}..."
+        ):
+            result = service.create_link_type(
+                ontology_rid=ontology_rid,
+                api_name=api_name,
+                from_object_type=from_object,
+                to_object_type=to_object,
+                display_name=display_name,
+                description=description,
+                reverse_api_name=reverse_api_name,
+            )
+
+        formatter.format_dict(result, format=format, output=output)
+
+        if output:
+            formatter.print_success(f"Link type creation 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 create link type: {e}")
+        raise typer.Exit(1)
+
+
 # Object operations
 @app.command("object-list")
 def list_objects(

{pltr_cli-0.14.1 → pltr_cli-0.15.0}/src/pltr/services/language_models.py

@@ -3,13 +3,29 @@ LanguageModels service wrapper for Foundry SDK.
 Provides access to Anthropic Claude models and OpenAI embeddings.
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
+import json
+import requests
+from urllib.parse import quote
 from .base import BaseService
 
 
 class LanguageModelsService(BaseService):
     """Service wrapper for Foundry LanguageModels operations."""
 
+    _MODEL_LIST_ENDPOINTS = [
+        "/v2/languageModels",
+        "/api/v2/llm/proxy/openai/v1/models",
+    ]
+    _MODEL_STATUS_ENDPOINTS = [
+        "/v2/languageModels/{model_id}",
+        "/api/v2/llm/models/{model_id}",
+    ]
+    _MODEL_ENROLL_ENDPOINTS = [
+        "/v2/languageModels/{model_id}/enroll",
+        "/api/v2/llm/models/{model_id}/enroll",
+    ]
+
     def _get_service(self) -> Any:
         """Get the Foundry LanguageModels service."""
         return self.client.language_models
@@ -71,7 +87,7 @@ class LanguageModelsService(BaseService):
             # Transform simple message to SDK message format
             messages = [
                 {
-                    "role": "user",
+                    "role": "USER",
                     "content": [{"type": "text", "text": message}],
                 }
             ]
@@ -134,7 +150,7 @@ class LanguageModelsService(BaseService):
             model_id: Model Resource Identifier
                 Format: ri.language-models.main.model.<id>
             messages: List of message objects with role and content
-                Format: [{"role": "user|assistant", "content": [...]}]
+                Format: [{"role": "USER|ASSISTANT", "content": [...]}]
             max_tokens: Maximum tokens to generate
             system: Optional system prompt blocks
                 Format: [{"type": "text", "text": "..."}]
@@ -162,9 +178,9 @@ class LanguageModelsService(BaseService):
         Example:
             >>> service = LanguageModelsService()
             >>> messages = [
-            ...     {"role": "user", "content": [{"type": "text", "text": "Hi"}]},
-            ...     {"role": "assistant", "content": [{"type": "text", "text": "Hello!"}]},
-            ...     {"role": "user", "content": [{"type": "text", "text": "Help me"}]}
+            ...     {"role": "USER", "content": [{"type": "text", "text": "Hi"}]},
+            ...     {"role": "ASSISTANT", "content": [{"type": "text", "text": "Hello!"}]},
+            ...     {"role": "USER", "content": [{"type": "text", "text": "Help me"}]}
             ... ]
             >>> response = service.send_messages_advanced(
             ...     "ri.language-models.main.model.abc123",
@@ -173,9 +189,17 @@ class LanguageModelsService(BaseService):
             ... )
         """
         try:
+            normalized_messages: List[Dict[str, Any]] = []
+            for msg in messages:
+                normalized_msg = dict(msg)
+                role = normalized_msg.get("role")
+                if isinstance(role, str):
+                    normalized_msg["role"] = role.upper()
+                normalized_messages.append(normalized_msg)
+
             # Build SDK kwargs
             request_kwargs: Dict[str, Any] = {
-                "messages": messages,
+                "messages": normalized_messages,
                 "max_tokens": max_tokens,
                 "preview": preview,
             }
@@ -280,3 +304,244 @@ class LanguageModelsService(BaseService):
             raise RuntimeError(
                 f"Failed to generate embeddings with model {model_id}: {e}"
             )
+
+    def list_available_models(self) -> List[Dict[str, Any]]:
+        """
+        List language models available to the authenticated user.
+
+        Tries the platform language-model listing endpoint first, then falls back
+        to the provider-compatible OpenAI models endpoint.
+        Note: This currently reads a single response per endpoint and does not
+        follow pagination tokens.
+
+        Returns:
+            List of model dictionaries with normalized keys:
+            - model_rid
+            - status
+            - type
+            - display_name
+
+        Raises:
+            RuntimeError: If no listing endpoint succeeds
+        """
+        last_error: Optional[Exception] = None
+
+        for endpoint in self._MODEL_LIST_ENDPOINTS:
+            try:
+                response = self._make_request("GET", endpoint)
+            except (requests.RequestException, RuntimeError) as e:
+                last_error = e
+                continue
+
+            payload = response.json() if response.text else {}
+            return self._normalize_model_list(
+                payload,
+                is_openai_source=("openai/v1/models" in endpoint),
+            )
+
+        raise RuntimeError(f"Failed to list available language models: {last_error}")
+
+    def _normalize_model_list(
+        self, payload: Union[Dict[str, Any], List[Any]], is_openai_source: bool = False
+    ) -> List[Dict[str, Any]]:
+        """Normalize varied model list payloads into a stable CLI schema."""
+        raw_models: List[Any] = []
+        if isinstance(payload, dict):
+            if "data" in payload:
+                data = payload.get("data")
+                if isinstance(data, list):
+                    raw_models = data
+            elif "models" in payload:
+                models = payload.get("models")
+                if isinstance(models, list):
+                    raw_models = models
+        elif isinstance(payload, list):
+            raw_models = payload
+
+        normalized: List[Dict[str, Any]] = []
+        for model in raw_models:
+            if not isinstance(model, dict):
+                continue
+
+            model_id = (
+                model.get("rid")
+                or model.get("modelRid")
+                or model.get("id")
+                or model.get("apiName")
+                or model.get("name")
+            )
+            if not model_id:
+                continue
+
+            status = (
+                model.get("status")
+                or model.get("enrollmentStatus")
+                or ("AVAILABLE" if is_openai_source else "UNKNOWN")
+            )
+
+            model_type = (
+                model.get("type")
+                or model.get("provider")
+                or model.get("modelType")
+                or model.get("family")
+                or ("OPENAI" if is_openai_source else "UNKNOWN")
+            )
+
+            normalized.append(
+                {
+                    "model_rid": str(model_id),
+                    "status": str(status),
+                    "type": str(model_type),
+                    "display_name": (
+                        model.get("displayName")
+                        or model.get("name")
+                        or model.get("id")
+                        or str(model_id)
+                    ),
+                }
+            )
+
+        normalized.sort(key=lambda item: item["model_rid"])
+        return normalized
+
+    def get_model_enrollment_status(self, model_id: str) -> Dict[str, Any]:
+        """
+        Get enrollment status for a language model.
+
+        Args:
+            model_id: Model RID or API name
+
+        Returns:
+            Dictionary with normalized keys:
+            - model_rid
+            - status
+            - type
+            - display_name
+        """
+        encoded_model_id = quote(model_id, safe="")
+        last_error: Optional[Exception] = None
+
+        for endpoint_template in self._MODEL_STATUS_ENDPOINTS:
+            endpoint = endpoint_template.format(model_id=encoded_model_id)
+            try:
+                response = self._make_request("GET", endpoint)
+                payload = response.json() if response.text else {}
+                return self._normalize_single_model_status(model_id, payload)
+            except (
+                requests.RequestException,
+                RuntimeError,
+                json.JSONDecodeError,
+            ) as e:
+                last_error = e
+                continue
+
+        # Fallback: infer availability from provider-compatible OpenAI models list.
+        try:
+            response = self._make_request("GET", "/api/v2/llm/proxy/openai/v1/models")
+            payload = response.json() if response.text else {}
+        except (
+            requests.RequestException,
+            RuntimeError,
+            json.JSONDecodeError,
+        ) as fallback_error:
+            raise RuntimeError(
+                f"Failed to get model enrollment status for {model_id}. "
+                f"Primary endpoint error: {last_error}. "
+                f"Fallback endpoint error: {fallback_error}"
+            )
+
+        for item in payload.get("data", []) if isinstance(payload, dict) else []:
+            if isinstance(item, dict) and item.get("id") == model_id:
+                return self._normalize_single_model_status(
+                    model_id,
+                    item,
+                    default_status="AVAILABLE_VIA_PROXY",
+                    default_type="OPENAI",
+                    default_display_name=model_id,
+                )
+
+        raise RuntimeError(
+            f"Model '{model_id}' not found via any known endpoint. "
+            f"Last primary endpoint error: {last_error}"
+        )
+
+    def enroll_model(self, model_id: str) -> Dict[str, Any]:
+        """
+        Enroll or enable a language model for API usage.
+
+        Args:
+            model_id: Model RID or API name
+
+        Returns:
+            Enrollment result dictionary with normalized keys:
+            - model_rid
+            - status
+            - type
+            - display_name
+        """
+        encoded_model_id = quote(model_id, safe="")
+        last_error: Optional[Exception] = None
+
+        for endpoint_template in self._MODEL_ENROLL_ENDPOINTS:
+            endpoint = endpoint_template.format(model_id=encoded_model_id)
+            try:
+                response = self._make_request("POST", endpoint, json_data={})
+                payload = response.json() if response.text else {}
+                return self._normalize_single_model_status(
+                    model_id, payload, default_status="ENROLLED"
+                )
+            except (
+                requests.RequestException,
+                RuntimeError,
+                json.JSONDecodeError,
+            ) as e:
+                last_error = e
+                continue
+
+        raise RuntimeError(
+            f"Failed to enroll model {model_id}. "
+            f"Enrollment may require Model Catalog UI access for this model: {last_error}"
+        )
+
+    def _normalize_single_model_status(
+        self,
+        model_id: str,
+        payload: Dict[str, Any],
+        default_status: str = "UNKNOWN",
+        default_type: str = "UNKNOWN",
+        default_display_name: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Normalize status payloads from varying endpoints."""
+        model_data = payload.get("data") if isinstance(payload, dict) else None
+        if isinstance(model_data, dict):
+            payload = model_data
+
+        if not isinstance(payload, dict):
+            payload = {}
+
+        return {
+            "model_rid": str(
+                payload.get("rid")
+                or payload.get("modelRid")
+                or payload.get("id")
+                or model_id
+            ),
+            "status": str(
+                payload.get("status")
+                or payload.get("enrollmentStatus")
+                or default_status
+            ),
+            "type": str(
+                payload.get("type")
+                or payload.get("provider")
+                or payload.get("modelType")
+                or default_type
+            ),
+            "display_name": str(
+                payload.get("displayName")
+                or payload.get("name")
+                or payload.get("id")
+                or default_display_name
+                or model_id
+            ),
+        }