Improvements and final execution changes

cvgpu.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+dir=$(dirname "$0")
+python_executable="$dir/miniconda3/bin/python"
+
+$python_executable python/gpu_status.py $@

gpu_status.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-

python/gpu_status.py

@@ -34,6 +34,18 @@ parser.add_argument(
     action="store_true", 
     help="Flag; if set, a compact overview will be displayed."
 )
+parser.add_argument(
+    "-uc", 
+    "--ultracompact", 
+    action="store_true", 
+    help="Flag; if set, a very compact overview will be displayed."
+)
+parser.add_argument(
+    "-u", 
+    "--users", 
+    action="store_true", 
+    help="Flag; if set, the current users of each GPU will be displayed."
+)
 parser.add_argument(
     "-f",
     "--filter",
@@ -45,22 +57,35 @@ parser.add_argument(
 
 args = parser.parse_args()
 
-response = requests.get(f"{args.protocol}://{args.server}:{args.port}/api/clients/")
+response = requests.get(
+    f"{args.protocol}://{args.server}:{args.port}/api/clients/"
+)
 
-if not args.compact:
+if args.ultracompact:
     renderer = Renderer(
-        columns=1,
-        progress_bar_width=50,
-        use_space_lines=True,
-        node_names=args.filter
+        columns=3,
+        progress_bar_width=30,
+        use_space_lines=False,
+        node_names=args.filter,
+        display_power=False,
+        display_users=args.users,
     )
-else:
+elif args.compact:
     renderer = Renderer(
         columns=2,
         progress_bar_width=40,
         use_space_lines=False,
         node_names=args.filter,
-        display_power=False,
+        display_power=True,
+        display_users=args.users,
+    )
+else:
+    renderer = Renderer(
+        columns=1,
+        progress_bar_width=50,
+        use_space_lines=True,
+        node_names=args.filter,
+        display_users=args.users,
     )
 
 print(renderer.render_info_dict(response.json()))

python/renderer.py

@@ -2,12 +2,21 @@ from math import ceil
 
 
 class Renderer:
-    def __init__(self, progress_bar_width=50, columns=1, use_space_lines=True, node_names=None, display_power=True) -> None:
+    def __init__(
+        self, 
+        progress_bar_width=50, 
+        columns=1, 
+        use_space_lines=True, 
+        node_names=None, 
+        display_power=True,
+        display_users=False,
+    ) -> None:
         self.progress_bar_width = progress_bar_width
         self.columns = columns
         self.use_space_lines = use_space_lines
         self.node_names = node_names
         self.display_power = display_power
+        self.display_users = display_users
 
     def render_info_dict(self, info_dict):
         line_blocks = []
@@ -28,12 +37,25 @@ class Renderer:
         for row in range(n_rows):
             lines = []
 
+            max_size = -1
+
+            # Find max size of the blocks in the same row:
+            for col in range(self.columns):
+                if col * n_rows + row < len(line_blocks):
+                    if len(line_blocks[col * n_rows + row]) > max_size:
+                        max_size = len(line_blocks[col * n_rows + row])
+
             for col in range(self.columns):
                 if col * n_rows + row < len(line_blocks):
                     if len(lines) == 0:
-                        lines.extend(line_blocks[col * n_rows + row])
+                        lines.extend(
+                            self.expand_rendered_block_to_size(
+                                line_blocks[col * n_rows + row], 
+                                max_size
+                            )
+                        )
                     else:
-                        for i, line in enumerate(line_blocks[col * n_rows + row]):
+                        for i, line in enumerate(self.expand_rendered_block_to_size(line_blocks[col * n_rows + row], max_size)):
                             lines[i] += line
             
             final_lines.extend(lines)            
@@ -59,19 +81,14 @@ class Renderer:
         for i, gpu_dict in enumerate(node_dict["gpus"]):
             lines.extend(self.get_rendered_gpu_lines(gpu_dict))
 
-            if i != len(node_dict["gpus"]) - 1:
-                if self.use_space_lines:
-                    lines.append("|" + "-" * (len(lines[-1]) - 2) + "|")
-                else:
-                    lines.append("|" + " " * (len(lines[-1]) - 2) + "|")
-            else:
-                lines.append("|" + "=" * (len(lines[-1]) - 2) + "|")
-
         head_line = head_line + "-" * (len(lines[-1]) - len(head_line) - 1) + "|"
         info_line = info_line + " " * (len(lines[-1]) - len(info_line) - 1) + "|"
         pad_line = "|" + "-" * (len(lines[-1]) - 2) + "|"
         pad_line_empty = "|" + " " * (len(lines[-1]) - 2) + "|"
 
+        lines.append(pad_line_empty)
+        lines.append("|" + "=" * (len(lines[-1]) - 2) + "|")
+
         lines.insert(0, pad_line)
         if self.use_space_lines:
             lines.insert(0, pad_line_empty)
@@ -82,7 +99,6 @@ class Renderer:
 
         return lines
 
-
     def get_rendered_gpu_lines(self, gpu_dict):
         gpu_type = gpu_dict["type"]
         index = gpu_dict["index"]
@@ -101,14 +117,32 @@ class Renderer:
             " " * rest_mem + "]" + \
             f"{mem_used:>6}/{mem_total:<6} MB,  Util: {int(utilization):>3}% |"
 
-        line_meta = f"| GPU #{index} ({gpu_type}):   #Proc.: {n_processes}   Temp: {temp:>3}°C   " + (f"Power: {int(power):>3} W" if self.display_power else "")
+        line_meta = f"| GPU #{index} ({gpu_type}):   #Proc.: {n_processes}   Temp: {temp:>3}°C   " + (f"Pow: {int(power):>3} W" if self.display_power else "")
 
         line_meta = line_meta + " " * (len(line_util) - len(line_meta) - 1) + "|"
         empty_line = "|" + " " * (len(line_meta) - 2) + "|"
 
+        lines = [line_meta, line_util]
+
+        if self.display_users:
+            lines.append(self.get_rendered_users_line(gpu_dict["running_processes"], len(line_meta)))
+
         if self.use_space_lines:
-            return [empty_line, line_meta, line_util, empty_line]
-        else:
-            return [line_meta, line_util]
+            lines = [empty_line] + lines
+
+        return lines
+
+    def get_rendered_users_line(self, processes_list, line_len):
+        user_names = [p_dict["user_name"] for p_dict in processes_list]
+        
+        line = "| Users: " + ", ".join(user_names)
+        line += " " * (line_len - len(line) - 1) + "|"
+
+        return line
+
+    def expand_rendered_block_to_size(self, block_lines, max_size):
+        buffer_line = "|" + " " * (len(block_lines[-1]) - 2) + "|"
+
+        block_lines_new = block_lines[:-1] + [buffer_line] * (max_size - len(block_lines)) + block_lines[-1:]
 
-            
+        return block_lines_new