Status message on fail

Author: kks32

dapi/__init__.py

@@ -44,7 +44,6 @@
     "AuthenticationError",
     "FileOperationError",
     "AppDiscoveryError",
-    "SystemInfoError"
-    "JobSubmissionError",
+    "SystemInfoError" "JobSubmissionError",
     "JobMonitorError",
 ]

dapi/client.py

@@ -4,7 +4,7 @@
 from . import apps as apps_module
 from . import files as files_module
 from . import jobs as jobs_module
-from . import systems as systems_module 
+from . import systems as systems_module
 from .db.accessor import DatabaseAccessor
 
 # Import only the necessary classes/functions from jobs
@@ -65,14 +65,18 @@ def download(self, *args, **kwargs):
     def list(self, *args, **kwargs) -> List[Tapis]:
         return files_module.list_files(self._tapis, *args, **kwargs)
 
+
 class SystemMethods:
     def __init__(self, tapis_client: Tapis):
         self._tapis = tapis_client
 
     def list_queues(self, system_id: str, verbose: bool = True) -> List[Any]:
         """Lists logical queues for a given Tapis system."""
-        return systems_module.list_system_queues(self._tapis, system_id, verbose=verbose)
-    
+        return systems_module.list_system_queues(
+            self._tapis, system_id, verbose=verbose
+        )
+
+
 class JobMethods:
     def __init__(self, tapis_client: Tapis):
         self._tapis = tapis_client

dapi/exceptions.py

@@ -24,8 +24,10 @@ class AppDiscoveryError(DapiException):
 
     pass
 
+
 class SystemInfoError(DapiException):
     """Error retrieving information about Tapis systems or queues."""
+
     pass
 
 

dapi/files.py

@@ -61,7 +61,7 @@ def get_ds_path_uri(t: Tapis, path: str, verify_exists: bool = False) -> str:
     current_username = getattr(t, "username", None)
     # ---
 
-    input_uri = None # Initialize variable
+    input_uri = None  # Initialize variable
 
     # 1. Handle MyData variations
     mydata_patterns = [
@@ -83,13 +83,17 @@ def get_ds_path_uri(t: Tapis, path: str, verify_exists: bool = False) -> str:
                 )
             path_remainder = path.split(pattern, 1)[1].lstrip("/")
             if use_username:
-                tapis_path = f"{current_username}/{path_remainder}" if path_remainder else current_username
+                tapis_path = (
+                    f"{current_username}/{path_remainder}"
+                    if path_remainder
+                    else current_username
+                )
             else:
                 tapis_path = path_remainder
             encoded_path = urllib.parse.quote(tapis_path)
             input_uri = f"tapis://{storage_system_id}/{encoded_path}"
             print(f"Translated '{path}' to '{input_uri}' using t.username")
-            break # Found match, exit loop
+            break  # Found match, exit loop
 
     # 2. Handle Community variations (if not already matched)
     if input_uri is None:
@@ -105,7 +109,7 @@ def get_ds_path_uri(t: Tapis, path: str, verify_exists: bool = False) -> str:
                 encoded_path = urllib.parse.quote(tapis_path)
                 input_uri = f"tapis://{storage_system_id}/{encoded_path}"
                 print(f"Translated '{path}' to '{input_uri}'")
-                break # Found match, exit loop
+                break  # Found match, exit loop
 
     # 3. Handle Project variations (if not already matched)
     if input_uri is None:
@@ -120,51 +124,81 @@ def get_ds_path_uri(t: Tapis, path: str, verify_exists: bool = False) -> str:
             if pattern in path:
                 path_remainder_full = path.split(pattern, 1)[1].lstrip("/")
                 if not path_remainder_full:
-                    raise ValueError(f"Project path '{path}' is incomplete. Missing project ID.")
+                    raise ValueError(
+                        f"Project path '{path}' is incomplete. Missing project ID."
+                    )
                 parts = path_remainder_full.split("/", 1)
                 project_id_part = parts[0]
                 path_within_project = parts[1] if len(parts) > 1 else ""
 
                 print(f"Searching Tapis systems for project ID '{project_id_part}'...")
                 found_system_id = None
                 try:
-                    search_query = f"description.like.%{project_id_part}%&id.like.{system_prefix}*"
-                    systems = t.systems.getSystems(search=search_query, listType="ALL", select="id,owner,description", limit=10)
+                    search_query = (
+                        f"description.like.%{project_id_part}%&id.like.{system_prefix}*"
+                    )
+                    systems = t.systems.getSystems(
+                        search=search_query,
+                        listType="ALL",
+                        select="id,owner,description",
+                        limit=10,
+                    )
                     matches = []
                     if systems:
                         for sys in systems:
-                            if project_id_part.lower() in getattr(sys, "description", "").lower():
+                            if (
+                                project_id_part.lower()
+                                in getattr(sys, "description", "").lower()
+                            ):
                                 matches.append(sys.id)
                     if len(matches) == 1:
                         found_system_id = matches[0]
                         print(f"Found unique matching system: {found_system_id}")
                     elif len(matches) == 0:
                         if "-" in project_id_part and len(project_id_part) > 30:
                             potential_sys_id = f"{system_prefix}{project_id_part}"
-                            print(f"Search failed, attempting direct lookup for system ID: {potential_sys_id}")
+                            print(
+                                f"Search failed, attempting direct lookup for system ID: {potential_sys_id}"
+                            )
                             try:
-                                t.systems.getSystem(systemId=potential_sys_id, select="id") # Select minimal field
+                                t.systems.getSystem(
+                                    systemId=potential_sys_id, select="id"
+                                )  # Select minimal field
                                 found_system_id = potential_sys_id
                                 print(f"Direct lookup successful: {found_system_id}")
                             except BaseTapyException:
-                                print(f"Direct lookup for {potential_sys_id} also failed.")
-                                raise FileOperationError(f"No project system found matching ID '{project_id_part}' via Tapis v3 search or direct UUID lookup.")
+                                print(
+                                    f"Direct lookup for {potential_sys_id} also failed."
+                                )
+                                raise FileOperationError(
+                                    f"No project system found matching ID '{project_id_part}' via Tapis v3 search or direct UUID lookup."
+                                )
                         else:
-                            raise FileOperationError(f"No project system found matching ID '{project_id_part}' via Tapis v3 search.")
+                            raise FileOperationError(
+                                f"No project system found matching ID '{project_id_part}' via Tapis v3 search."
+                            )
                     else:
-                        raise FileOperationError(f"Multiple project systems found potentially matching ID '{project_id_part}': {matches}. Cannot determine unique system.")
+                        raise FileOperationError(
+                            f"Multiple project systems found potentially matching ID '{project_id_part}': {matches}. Cannot determine unique system."
+                        )
                 except BaseTapyException as e:
-                    raise FileOperationError(f"Tapis API error searching for project system '{project_id_part}': {e}") from e
+                    raise FileOperationError(
+                        f"Tapis API error searching for project system '{project_id_part}': {e}"
+                    ) from e
                 except Exception as e:
-                    raise FileOperationError(f"Unexpected error searching for project system '{project_id_part}': {e}") from e
+                    raise FileOperationError(
+                        f"Unexpected error searching for project system '{project_id_part}': {e}"
+                    ) from e
 
                 if not found_system_id:
-                    raise FileOperationError(f"Could not resolve project ID '{project_id_part}' to a Tapis system ID.")
+                    raise FileOperationError(
+                        f"Could not resolve project ID '{project_id_part}' to a Tapis system ID."
+                    )
 
                 encoded_path_within_project = urllib.parse.quote(path_within_project)
                 input_uri = f"tapis://{found_system_id}/{encoded_path_within_project}"
                 print(f"Translated '{path}' to '{input_uri}' using Tapis v3 lookup")
-                break # Found match, exit loop
+                break  # Found match, exit loop
 
     # 4. Handle direct tapis:// URI input (if not already matched)
     if input_uri is None and path.startswith("tapis://"):
@@ -194,16 +228,26 @@ def get_ds_path_uri(t: Tapis, path: str, verify_exists: bool = False) -> str:
             print(f"Verification successful: Path exists.")
         except BaseTapyException as e:
             # Specifically check for 404 on the listFiles call
-            if hasattr(e, 'response') and e.response and e.response.status_code == 404:
-                raise FileOperationError(f"Verification failed: Path '{decoded_remote_path}' does not exist on system '{system_id}'. Translated URI: {input_uri}") from e
+            if hasattr(e, "response") and e.response and e.response.status_code == 404:
+                raise FileOperationError(
+                    f"Verification failed: Path '{decoded_remote_path}' does not exist on system '{system_id}'. Translated URI: {input_uri}"
+                ) from e
             else:
                 # Re-raise other Tapis errors encountered during verification
-                raise FileOperationError(f"Verification error for path '{decoded_remote_path}' on system '{system_id}': {e}") from e
-        except ValueError as e: # Catch errors from _parse_tapis_uri if input_uri was bad
-             raise FileOperationError(f"Verification failed: Could not parse translated URI '{input_uri}' for verification. Error: {e}") from e
+                raise FileOperationError(
+                    f"Verification error for path '{decoded_remote_path}' on system '{system_id}': {e}"
+                ) from e
+        except (
+            ValueError
+        ) as e:  # Catch errors from _parse_tapis_uri if input_uri was bad
+            raise FileOperationError(
+                f"Verification failed: Could not parse translated URI '{input_uri}' for verification. Error: {e}"
+            ) from e
         except Exception as e:
-             # Catch other unexpected errors during verification
-            raise FileOperationError(f"Unexpected verification error for path at '{input_uri}': {e}") from e
+            # Catch other unexpected errors during verification
+            raise FileOperationError(
+                f"Unexpected verification error for path at '{input_uri}': {e}"
+            ) from e
 
     return input_uri
 

dapi/jobs.py

@@ -299,6 +299,31 @@ def get_status(self, force_refresh: bool = True) -> str:
                 f"Failed to get status for job {self.uuid}: {e}"
             ) from e
 
+    @property
+    def last_message(self) -> Optional[str]:
+        """
+        Retrieves the last status message recorded for the job.
+        This is typically found in the 'lastMessage' attribute of the job details.
+        Returns None if the message is not available or not set.
+        """
+        try:
+            details = self.details  # Ensures job details are loaded
+            message = getattr(details, "lastMessage", None)
+            if message:
+                # Sometimes messages might be empty strings, treat as None for consistency
+                return str(message).strip() if str(message).strip() else None
+            return None
+        except JobMonitorError as e:
+            print(
+                f"Could not retrieve job details to get last_message for job {self.uuid}: {e}"
+            )
+            return None
+        except Exception as e:
+            print(
+                f"An unexpected error occurred while fetching last_message for job {self.uuid}: {e}"
+            )
+            return None
+
     def monitor(self, interval: int = 15, timeout_minutes: Optional[int] = None) -> str:
         """
         Monitors the job status with tqdm progress bars until completion,
@@ -576,6 +601,97 @@ def download_output(self, remote_path: str, local_target: str):
                 f"Failed to download output '{remote_path}' for job {self.uuid}: {e}"
             ) from e
 
+    def get_output_content(
+        self,
+        output_filename: str,
+        max_lines: Optional[int] = None,
+        missing_ok: bool = True,
+    ) -> Optional[str]:
+        """
+        Retrieves the content of a specific output file from the job's archive.
+
+        Args:
+            output_filename: The name of the file in the job's archive root
+                             (e.g., "tapisjob.out", "tapisjob.err").
+            max_lines: If specified, returns only the last `max_lines` of the file.
+            missing_ok: If True and the file is not found, returns None.
+                        If False and not found, raises FileOperationError.
+
+        Returns:
+            The content of the file as a string, or None if not found (and missing_ok=True).
+
+        Raises:
+            FileOperationError: If the job archive is not available, the file is not found (and missing_ok=False),
+                                or if there's an error fetching the file.
+        """
+        print(f"Attempting to fetch content of '{output_filename}' from job archive...")
+        details = self._get_details()  # Ensure details are loaded
+        if not details.archiveSystemId or not details.archiveSystemDir:
+            raise FileOperationError(
+                f"Job {self.uuid} archive system ID or directory not available. Cannot fetch output."
+            )
+
+        full_archive_path = os.path.join(
+            details.archiveSystemDir, output_filename.lstrip("/")
+        )
+        full_archive_path = os.path.normpath(full_archive_path).lstrip("/")
+
+        try:
+            # self._tapis.files.getContents() is expected to return the full file content as bytes
+            # when the response is not JSON. The stream=True parameter is for the API endpoint.
+            content_bytes = self._tapis.files.getContents(
+                systemId=details.archiveSystemId,
+                path=full_archive_path,
+                stream=True,  # Good to keep, as it's a hint for the server
+            )
+
+            # Verify that we indeed received bytes
+            if not isinstance(content_bytes, bytes):
+                raise FileOperationError(
+                    f"Tapis API returned unexpected type for file content of '{output_filename}': {type(content_bytes)}. Expected bytes."
+                )
+
+            content_str = content_bytes.decode(
+                "utf-8", errors="replace"
+            )  # Decode to string
+
+            if max_lines is not None and max_lines > 0:
+                lines = content_str.splitlines()
+                if len(lines) > max_lines:
+                    # Slice to get the last max_lines
+                    content_str = "\n".join(lines[-max_lines:])
+                    print(f"Returning last {max_lines} lines of '{output_filename}'.")
+                else:
+                    print(
+                        f"File '{output_filename}' has {len(lines)} lines (less than/equal to max_lines={max_lines}). Returning full content."
+                    )
+            else:
+                print(f"Returning full content of '{output_filename}'.")
+            return content_str
+
+        except BaseTapyException as e:
+            if hasattr(e, "response") and e.response and e.response.status_code == 404:
+                if missing_ok:
+                    print(
+                        f"Output file '{output_filename}' not found in archive (missing_ok=True). Path: {details.archiveSystemId}/{full_archive_path}"
+                    )
+                    return None
+                else:
+                    raise FileOperationError(
+                        f"Output file '{output_filename}' not found in job archive "
+                        f"at system '{details.archiveSystemId}', path '{full_archive_path}'."
+                    ) from e
+            else:
+                raise FileOperationError(
+                    f"Tapis error fetching output file '{output_filename}' for job {self.uuid} (Path: {details.archiveSystemId}/{full_archive_path}): {e}"
+                ) from e
+        except FileOperationError:  # Re-raise FileOperationErrors from above
+            raise
+        except Exception as e:  # Catch other unexpected errors
+            raise FileOperationError(
+                f"Unexpected error fetching content of '{output_filename}' for job {self.uuid} (Path: {details.archiveSystemId}/{full_archive_path}): {e}"
+            ) from e
+
     def cancel(self):
         print(f"Attempting to cancel job {self.uuid}...")
         try: