pybiolib 1.2.659__tar.gz → 1.2.678__tar.gz

{pybiolib-1.2.659 → pybiolib-1.2.678}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pybiolib
-Version: 1.2.659
+Version: 1.2.678
 Summary: BioLib Python Client
 License: MIT
 Keywords: biolib

pybiolib-1.2.678/biolib/_internal/tree_utils.py

@@ -0,0 +1,106 @@
+"""Utilities for displaying file trees and formatting file sizes."""
+
+from typing import Any, Dict, List, Optional, Union
+
+from biolib.biolib_binary_format.utils import LazyLoadedFile
+
+
+def format_size(size_bytes: int) -> str:
+    """Convert bytes to human-readable format (e.g., 2.5KB).
+
+    Args:
+        size_bytes: File size in bytes
+
+    Returns:
+        Human-readable string representation of the file size
+    """
+    if size_bytes < 1024:
+        return f'{size_bytes}B'
+    elif size_bytes < 1024 * 1024:
+        return f'{size_bytes/1024:.1f}KB'
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f'{size_bytes/(1024*1024):.1f}MB'
+    else:
+        return f'{size_bytes/(1024*1024*1024):.1f}GB'
+
+
+def build_tree_str(
+    data: Dict[str, Any],
+    prefix: str = '',
+    tree_lines: Optional[List[str]] = None,
+    blue: str = '\033[34m',
+    white: str = '\033[90m',  # Changed from white (37m) to dark gray (90m) for better visibility on light backgrounds
+    reset: str = '\033[0m',
+) -> List[str]:
+    """Build a string representation of a file tree with color-coded directories and files.
+
+    Args:
+        data: Hierarchical tree structure of directories and files
+        prefix: Line prefix for indentation and tree structure characters
+        tree_lines: List to accumulate tree lines
+        blue: ANSI color code for directories
+        white: ANSI color code for files (defaults to dark gray for visibility on light backgrounds)
+        reset: ANSI color code to reset color
+
+    Returns:
+        List of tree lines for display
+    """
+    if tree_lines is None:
+        tree_lines = []
+
+    # Get sorted items, keeping directories first
+    items = sorted([(k, v) for k, v in data.items() if k != '__files__'])
+    files_list = sorted(data.get('__files__', []), key=lambda f: f['name'])
+
+    # Add directories
+    for i, (key, value) in enumerate(items):
+        is_last_dir = i == len(items) - 1 and not files_list
+
+        if is_last_dir:
+            tree_lines.append(f'{prefix}└── {blue}{key}{reset}')
+            build_tree_str(value, prefix + '    ', tree_lines, blue, white, reset)
+        else:
+            tree_lines.append(f'{prefix}├── {blue}{key}{reset}')
+            build_tree_str(value, prefix + '│   ', tree_lines, blue, white, reset)
+
+    # Add files with their sizes
+    for i, file in enumerate(files_list):
+        is_last = i == len(files_list) - 1
+        size_str = format_size(file['size'])
+        file_name = file['name']
+
+        if is_last:
+            tree_lines.append(f'{prefix}└── {white}{file_name} ({size_str}){reset}')
+        else:
+            tree_lines.append(f'{prefix}├── {white}{file_name} ({size_str}){reset}')
+
+    return tree_lines
+
+
+def build_tree_from_files(files: List[LazyLoadedFile]) -> Dict[str, Union[Dict[str, Any], List[Dict[str, Any]]]]:
+    """Build a hierarchical tree structure from a list of files.
+
+    Args:
+        files: List of files to organize into a tree
+
+    Returns:
+        Hierarchical tree structure of directories and files
+    """
+    tree: Dict[str, Union[Dict[str, Any], List[Dict[str, Any]]]] = {}
+    for file in files:
+        parts = file.path.lstrip('/').split('/')
+        current: Dict[str, Union[Dict[str, Any], List[Dict[str, Any]]]] = tree
+        for i, part in enumerate(parts):
+            if i == len(parts) - 1:  # This is a file
+                if '__files__' not in current:
+                    current['__files__'] = []
+                files_list = current['__files__']
+                assert isinstance(files_list, list)
+                files_list.append({'name': part, 'size': file.length})
+            else:  # This is a directory
+                if part not in current:
+                    current[part] = {}
+                dir_dict = current[part]
+                assert isinstance(dir_dict, dict)
+                current = dir_dict
+    return tree

{pybiolib-1.2.659 → pybiolib-1.2.678}/biolib/jobs/job.py

@@ -9,6 +9,7 @@ from urllib.parse import urlparse
 import biolib.api.client
 from biolib import utils
 from biolib._internal.http_client import HttpClient
+from biolib._internal.tree_utils import build_tree_from_files, build_tree_str
 from biolib._internal.utils import open_browser_window_from_notebook
 from biolib.api.client import ApiClient
 from biolib.biolib_api_client import BiolibApiClient, CreatedJobDict
@@ -56,7 +57,48 @@ class Job:
         return f"Job for {self._job_dict['app_uri']} created at {self._job_dict['created_at']} ({self._uuid})"
 
     def __repr__(self):
-        return f'Job: {self._uuid}'
+        # Get job status and shareable link
+        status = self.get_status()
+        shareable_link = self.get_shareable_link()
+
+        # ANSI color codes for terminal output
+        blue = '\033[34m'
+        white = '\033[37m'
+        reset = '\033[0m'
+
+        # Start with the header section
+        output_lines = [
+            '--- BioLib Result ---',
+            f'ID: {self._uuid}',
+            f'Status: {status}',
+            f'Link: {shareable_link}',
+        ]
+
+        # Only show output files if the job is not pending
+        if not self.is_pending():
+            output_lines.append('Output Files:')
+
+            try:
+                # Get files from the job
+                files = self.list_output_files()
+
+                # If no files, indicate that
+                if not files:
+                    output_lines.append('No output files')
+                    return '\n'.join(output_lines)
+
+                # If more than 25 files, show simplified message
+                if len(files) > 25:
+                    output_lines.append(f'{len(files)} output files in result.')
+                    return '\n'.join(output_lines)
+
+                # Build the tree representation
+                tree_data = build_tree_from_files(files)
+                output_lines.extend(build_tree_str(tree_data, blue=blue, white=white, reset=reset))
+            except Exception:
+                output_lines.append('Error accessing output files')
+
+        return '\n'.join(output_lines)
 
     @property
     def id(self) -> str:  # pylint: disable=invalid-name
@@ -128,6 +170,21 @@ class Job:
         self,
         path_filter: Optional[PathFilter] = None,
     ) -> List[LazyLoadedFile]:
+        """List output files from the job.
+
+        Args:
+            path_filter (PathFilter, optional): Filter to apply to the output files.
+                Can be a string glob pattern or a callable that takes a path string and returns a boolean.
+
+        Returns:
+            List[LazyLoadedFile]: List of output files.
+
+        Example::
+            >>> job = biolib.get_job("job_id")
+            >>> output_files = job.list_output_files()
+            >>> # Filter files with a glob pattern
+            >>> output_files = job.list_output_files("*.pdb")
+        """
         return self.result.list_output_files(path_filter=path_filter)
 
     def get_output_file(self, filename: str) -> LazyLoadedFile:

{pybiolib-1.2.659 → pybiolib-1.2.678}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pybiolib"
-version = "1.2.659"
+version = "1.2.678"
 description = "BioLib Python Client"
 readme = "PYPI_README.md"
 license = "MIT"