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

pltr/utils/formatting.py

@@ -537,3 +537,748 @@ class OutputFormatter:
             return self.format_output(display_data, format_type, output_file)
         else:
             return self.format_output(status_info, format_type, output_file)
+
+    # ============================================================================
+    # Orchestration Formatting Methods
+    # ============================================================================
+
+    def format_build_detail(
+        self,
+        build: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format detailed build information.
+
+        Args:
+            build: Build dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            # For table format, show key-value pairs
+            details = []
+
+            # Define the order of properties to display
+            property_order = [
+                "rid",
+                "status",
+                "created_by",
+                "created_time",
+                "started_time",
+                "finished_time",
+                "branch_name",
+                "commit_hash",
+            ]
+
+            for prop in property_order:
+                if build.get(prop) is not None:
+                    value = build[prop]
+                    # Format timestamps
+                    if "time" in prop:
+                        value = self._format_datetime(value)
+                    details.append(
+                        {
+                            "Property": prop.replace("_", " ").title(),
+                            "Value": str(value),
+                        }
+                    )
+
+            # Add any remaining properties
+            for key, value in build.items():
+                if key not in property_order and value is not None:
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(build, format_type, output_file)
+
+    def format_builds_list(
+        self,
+        builds: List[Dict[str, Any]],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format list of builds.
+
+        Args:
+            builds: List of build dictionaries
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        formatted_builds = []
+        for build in builds:
+            formatted_build = {
+                "RID": build.get("rid", ""),
+                "Status": build.get("status", ""),
+                "Created By": build.get("created_by", ""),
+                "Created": self._format_datetime(build.get("created_time")),
+                "Branch": build.get("branch_name", ""),
+            }
+            formatted_builds.append(formatted_build)
+
+        return self.format_output(formatted_builds, format_type, output_file)
+
+    def format_job_detail(
+        self,
+        job: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format detailed job information.
+
+        Args:
+            job: Job dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            # For table format, show key-value pairs
+            details = []
+
+            # Define the order of properties to display
+            property_order = [
+                "rid",
+                "status",
+                "job_type",
+                "build_rid",
+                "created_time",
+                "started_time",
+                "finished_time",
+            ]
+
+            for prop in property_order:
+                if job.get(prop) is not None:
+                    value = job[prop]
+                    # Format timestamps
+                    if "time" in prop:
+                        value = self._format_datetime(value)
+                    details.append(
+                        {
+                            "Property": prop.replace("_", " ").title(),
+                            "Value": str(value),
+                        }
+                    )
+
+            # Add any remaining properties
+            for key, value in job.items():
+                if key not in property_order and value is not None:
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(job, format_type, output_file)
+
+    def format_jobs_list(
+        self,
+        jobs: List[Dict[str, Any]],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format list of jobs.
+
+        Args:
+            jobs: List of job dictionaries
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        formatted_jobs = []
+        for job in jobs:
+            formatted_job = {
+                "RID": job.get("rid", ""),
+                "Status": job.get("status", ""),
+                "Type": job.get("job_type", ""),
+                "Build": job.get("build_rid", "")[:12] + "..."
+                if job.get("build_rid")
+                else "",
+                "Started": self._format_datetime(job.get("started_time")),
+            }
+            formatted_jobs.append(formatted_job)
+
+        return self.format_output(formatted_jobs, format_type, output_file)
+
+    def format_schedule_detail(
+        self,
+        schedule: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format detailed schedule information.
+
+        Args:
+            schedule: Schedule dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            # For table format, show key-value pairs
+            details = []
+
+            # Define the order of properties to display
+            property_order = [
+                "rid",
+                "display_name",
+                "description",
+                "paused",
+                "created_by",
+                "created_time",
+                "modified_by",
+                "modified_time",
+            ]
+
+            for prop in property_order:
+                if schedule.get(prop) is not None:
+                    value = schedule[prop]
+                    # Format timestamps
+                    if "time" in prop:
+                        value = self._format_datetime(value)
+                    # Format boolean values
+                    elif prop == "paused":
+                        value = "Yes" if value else "No"
+                    details.append(
+                        {
+                            "Property": prop.replace("_", " ").title(),
+                            "Value": str(value),
+                        }
+                    )
+
+            # Handle special nested properties
+            if schedule.get("trigger"):
+                details.append(
+                    {"Property": "Trigger", "Value": str(schedule["trigger"])}
+                )
+            if schedule.get("action"):
+                details.append({"Property": "Action", "Value": str(schedule["action"])})
+
+            # Add any remaining properties
+            for key, value in schedule.items():
+                if (
+                    key not in property_order + ["trigger", "action"]
+                    and value is not None
+                ):
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(schedule, format_type, output_file)
+
+    def format_schedules_list(
+        self,
+        schedules: List[Dict[str, Any]],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format list of schedules.
+
+        Args:
+            schedules: List of schedule dictionaries
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        formatted_schedules = []
+        for schedule in schedules:
+            formatted_schedule = {
+                "RID": schedule.get("rid", ""),
+                "Name": schedule.get("display_name", ""),
+                "Description": schedule.get("description", "")[:50] + "..."
+                if schedule.get("description")
+                else "",
+                "Paused": "Yes" if schedule.get("paused") else "No",
+                "Created": self._format_datetime(schedule.get("created_time")),
+            }
+            formatted_schedules.append(formatted_schedule)
+
+        return self.format_output(formatted_schedules, format_type, output_file)
+
+    # MediaSets formatting methods
+
+    def format_media_item_info(
+        self,
+        media_item: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format media item information for display.
+
+        Args:
+            media_item: Media item information dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            details = []
+
+            property_order = [
+                ("media_item_rid", "Media Item RID"),
+                ("filename", "Filename"),
+                ("size", "Size"),
+                ("content_type", "Content Type"),
+                ("created_time", "Created"),
+                ("updated_time", "Updated"),
+            ]
+
+            for key, label in property_order:
+                if media_item.get(key) is not None:
+                    value = media_item[key]
+                    if key in ["created_time", "updated_time"]:
+                        value = self._format_datetime(value)
+                    elif key == "size":
+                        value = self._format_file_size(value)
+                    details.append({"Property": label, "Value": str(value)})
+
+            # Add any remaining properties
+            for key, value in media_item.items():
+                if (
+                    key not in [prop[0] for prop in property_order]
+                    and value is not None
+                ):
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(media_item, format_type, output_file)
+
+    def format_media_path_lookup(
+        self,
+        lookup_result: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format media path lookup result for display.
+
+        Args:
+            lookup_result: Path lookup result dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            details = [
+                {"Property": "Path", "Value": lookup_result.get("path", "")},
+                {"Property": "Media Item RID", "Value": lookup_result.get("rid", "")},
+            ]
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(lookup_result, format_type, output_file)
+
+    def format_media_reference(
+        self,
+        reference: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format media reference information for display.
+
+        Args:
+            reference: Media reference dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            details = []
+
+            property_order = [
+                ("reference_id", "Reference ID"),
+                ("url", "URL"),
+                ("expires_at", "Expires At"),
+            ]
+
+            for key, label in property_order:
+                if reference.get(key) is not None:
+                    value = reference[key]
+                    if key == "expires_at":
+                        value = self._format_datetime(value)
+                    details.append({"Property": label, "Value": str(value)})
+
+            # Add any remaining properties
+            for key, value in reference.items():
+                if (
+                    key not in [prop[0] for prop in property_order]
+                    and value is not None
+                ):
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(reference, format_type, output_file)
+
+    # Dataset formatting methods
+
+    def format_branches(
+        self,
+        branches: List[Dict[str, Any]],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format dataset branches for display.
+
+        Args:
+            branches: List of branch dictionaries
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        formatted_branches = []
+        for branch in branches:
+            formatted_branch = {
+                "Name": branch.get("name", ""),
+                "Transaction": branch.get("transaction_rid", "")[:12] + "..."
+                if branch.get("transaction_rid")
+                else "",
+                "Created": self._format_datetime(branch.get("created_time")),
+                "Created By": branch.get("created_by", ""),
+            }
+            formatted_branches.append(formatted_branch)
+
+        return self.format_output(formatted_branches, format_type, output_file)
+
+    def format_branch_detail(
+        self,
+        branch: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format detailed branch information.
+
+        Args:
+            branch: Branch dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            details = []
+
+            property_order = [
+                ("name", "Branch Name"),
+                ("dataset_rid", "Dataset RID"),
+                ("parent_branch", "Parent Branch"),
+                ("transaction_rid", "Transaction RID"),
+                ("created_time", "Created"),
+                ("created_by", "Created By"),
+            ]
+
+            for key, label in property_order:
+                if branch.get(key) is not None:
+                    value = branch[key]
+                    if key == "created_time":
+                        value = self._format_datetime(value)
+                    details.append({"Property": label, "Value": str(value)})
+
+            # Add any remaining properties
+            for key, value in branch.items():
+                if (
+                    key not in [prop[0] for prop in property_order]
+                    and value is not None
+                ):
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(branch, format_type, output_file)
+
+    def format_files(
+        self,
+        files: List[Dict[str, Any]],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format dataset files for display.
+
+        Args:
+            files: List of file dictionaries
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        formatted_files = []
+        for file in files:
+            formatted_file = {
+                "Path": file.get("path", ""),
+                "Size": self._format_file_size(file.get("size_bytes")),
+                "Last Modified": self._format_datetime(file.get("last_modified")),
+                "Transaction": file.get("transaction_rid", "")[:12] + "..."
+                if file.get("transaction_rid")
+                else "",
+            }
+            formatted_files.append(formatted_file)
+
+        return self.format_output(formatted_files, format_type, output_file)
+
+    def format_transactions(
+        self,
+        transactions: List[Dict[str, Any]],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format dataset transactions for display.
+
+        Args:
+            transactions: List of transaction dictionaries
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        formatted_transactions = []
+        for transaction in transactions:
+            formatted_transaction = {
+                "Transaction RID": transaction.get("transaction_rid", "")[:12] + "..."
+                if transaction.get("transaction_rid")
+                else "",
+                "Status": transaction.get("status", ""),
+                "Type": transaction.get("transaction_type", ""),
+                "Branch": transaction.get("branch", ""),
+                "Created": self._format_datetime(transaction.get("created_time")),
+                "Created By": transaction.get("created_by", ""),
+            }
+            formatted_transactions.append(formatted_transaction)
+
+        return self.format_output(formatted_transactions, format_type, output_file)
+
+    def format_transaction_detail(
+        self,
+        transaction: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format detailed transaction information.
+
+        Args:
+            transaction: Transaction dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            details = []
+
+            property_order = [
+                ("transaction_rid", "Transaction RID"),
+                ("dataset_rid", "Dataset RID"),
+                ("status", "Status"),
+                ("transaction_type", "Type"),
+                ("branch", "Branch"),
+                ("created_time", "Created"),
+                ("created_by", "Created By"),
+                ("committed_time", "Committed"),
+                ("aborted_time", "Aborted"),
+            ]
+
+            for key, label in property_order:
+                if transaction.get(key) is not None:
+                    value = transaction[key]
+                    if "time" in key:
+                        value = self._format_datetime(value)
+                    details.append({"Property": label, "Value": str(value)})
+
+            # Add any remaining properties
+            for key, value in transaction.items():
+                if (
+                    key not in [prop[0] for prop in property_order]
+                    and value is not None
+                ):
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(transaction, format_type, output_file)
+
+    def format_transaction_result(
+        self,
+        result: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format transaction operation result.
+
+        Args:
+            result: Transaction operation result dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            details = []
+
+            property_order = [
+                ("transaction_rid", "Transaction RID"),
+                ("dataset_rid", "Dataset RID"),
+                ("status", "Status"),
+                ("success", "Success"),
+                ("committed_time", "Committed Time"),
+                ("aborted_time", "Aborted Time"),
+            ]
+
+            for key, label in property_order:
+                if result.get(key) is not None:
+                    value = result[key]
+                    if "time" in key:
+                        value = self._format_datetime(value)
+                    elif key == "success":
+                        value = "Yes" if value else "No"
+                    details.append({"Property": label, "Value": str(value)})
+
+            # Add any remaining properties
+            for key, value in result.items():
+                if (
+                    key not in [prop[0] for prop in property_order]
+                    and value is not None
+                ):
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(result, format_type, output_file)
+
+    def format_views(
+        self,
+        views: List[Dict[str, Any]],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format dataset views for display.
+
+        Args:
+            views: List of view dictionaries
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        formatted_views = []
+        for view in views:
+            formatted_view = {
+                "View RID": view.get("view_rid", "")[:12] + "..."
+                if view.get("view_rid")
+                else "",
+                "Name": view.get("name", ""),
+                "Description": view.get("description", "")[:50] + "..."
+                if view.get("description", "")
+                else "",
+                "Created": self._format_datetime(view.get("created_time")),
+                "Created By": view.get("created_by", ""),
+            }
+            formatted_views.append(formatted_view)
+
+        return self.format_output(formatted_views, format_type, output_file)
+
+    def format_view_detail(
+        self,
+        view: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format detailed view information.
+
+        Args:
+            view: View dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            details = []
+
+            property_order = [
+                ("view_rid", "View RID"),
+                ("name", "Name"),
+                ("description", "Description"),
+                ("dataset_rid", "Dataset RID"),
+                ("created_time", "Created"),
+                ("created_by", "Created By"),
+            ]
+
+            for key, label in property_order:
+                if view.get(key) is not None:
+                    value = view[key]
+                    if key == "created_time":
+                        value = self._format_datetime(value)
+                    details.append({"Property": label, "Value": str(value)})
+
+            # Add any remaining properties
+            for key, value in view.items():
+                if (
+                    key not in [prop[0] for prop in property_order]
+                    and value is not None
+                ):
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(view, format_type, output_file)