multiSSH3 5.27__tar.gz → 5.33__tar.gz

{multissh3-5.27 → multissh3-5.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: multiSSH3
-Version: 5.27
+Version: 5.33
 Summary: Run commands on multiple hosts via SSH
 Home-page: https://github.com/yufei-pan/multiSSH3
 Author: Yufei Pan

{multissh3-5.27 → multissh3-5.33}/multiSSH3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: multiSSH3
-Version: 5.27
+Version: 5.33
 Summary: Run commands on multiple hosts via SSH
 Home-page: https://github.com/yufei-pan/multiSSH3
 Author: Yufei Pan

{multissh3-5.27 → multissh3-5.33}/multiSSH3.py

@@ -24,6 +24,7 @@ import shutil
 import getpass
 import uuid
 import tempfile
+import math
 
 try:
 	# Check if functiools.cache is available
@@ -36,7 +37,7 @@ except AttributeError:
 		# If neither is available, use a dummy decorator
 		def cache_decorator(func):
 			return func
-version = '5.27'
+version = '5.33'
 VERSION = version
 
 CONFIG_FILE = '/etc/multiSSH3.config.json'	
@@ -165,6 +166,7 @@ class Host:
 		self.stdout = [] # the stdout of the command
 		self.stderr = [] # the stderr of the command
 		self.printedLines = -1 # the number of lines printed on the screen
+		self.lineNumToReprintSet = set() # whether to reprint the last line
 		self.lastUpdateTime = time.time() # the last time the output was updated
 		self.files = files # the files to be copied to the host
 		self.ipmi = ipmi # whether to use ipmi to connect to the host
@@ -179,12 +181,17 @@ class Host:
 		self.uuid = uuid
 		self.identity_file = identity_file
 		self.ip = ip if ip else getIP(name)
+		self.current_color_pair = [-1, -1, 1]
 
 	def __iter__(self):
 		return zip(['name', 'command', 'returncode', 'stdout', 'stderr'], [self.name, self.command, self.returncode, self.stdout, self.stderr])
 	def __repr__(self):
 		# return the complete data structure
-		return f"Host(name={self.name}, command={self.command}, returncode={self.returncode}, stdout={self.stdout}, stderr={self.stderr}, output={self.output}, printedLines={self.printedLines}, files={self.files}, ipmi={self.ipmi}, interface_ip_prefix={self.interface_ip_prefix}, scp={self.scp}, gatherMode={self.gatherMode}, extraargs={self.extraargs}, resolvedName={self.resolvedName}, i={self.i}, uuid={self.uuid}), identity_file={self.identity_file}"
+		return f"Host(name={self.name}, command={self.command}, returncode={self.returncode}, stdout={self.stdout}, stderr={self.stderr}, \
+output={self.output}, printedLines={self.printedLines}, lineNumToReprintSet={self.lineNumToReprintSet}, files={self.files}, ipmi={self.ipmi}, \
+interface_ip_prefix={self.interface_ip_prefix}, scp={self.scp}, gatherMode={self.gatherMode}, \
+extraargs={self.extraargs}, resolvedName={self.resolvedName}, i={self.i}, uuid={self.uuid}), \
+identity_file={self.identity_file}, ip={self.ip}, current_color_pair={self.current_color_pair}"
 	def __str__(self):
 		return f"Host(name={self.name}, command={self.command}, returncode={self.returncode}, stdout={self.stdout}, stderr={self.stderr})"
 
@@ -341,7 +348,30 @@ if True:
 	__keyPressesIn = [[]]
 	_emo = False
 	_etc_hosts = __configs_from_file.get('_etc_hosts', __build_in_default_config['_etc_hosts'])
-
+	__curses_global_color_pairs = {(-1,-1):1}
+	__curses_current_color_pair_index = 2  # Start from 1, as 0 is the default color pair
+	__curses_color_table = {}
+	__curses_current_color_index = 10
+
+# Mapping of ANSI 4-bit colors to curses colors
+ANSI_TO_CURSES_COLOR = {
+	30: curses.COLOR_BLACK,
+	31: curses.COLOR_RED,
+	32: curses.COLOR_GREEN,
+	33: curses.COLOR_YELLOW,
+	34: curses.COLOR_BLUE,
+	35: curses.COLOR_MAGENTA,
+	36: curses.COLOR_CYAN,
+	37: curses.COLOR_WHITE,
+	90: curses.COLOR_BLACK,   # Bright Black (usually gray)
+	91: curses.COLOR_RED,     # Bright Red
+	92: curses.COLOR_GREEN,   # Bright Green
+	93: curses.COLOR_YELLOW,  # Bright Yellow
+	94: curses.COLOR_BLUE,    # Bright Blue
+	95: curses.COLOR_MAGENTA, # Bright Magenta
+	96: curses.COLOR_CYAN,    # Bright Cyan
+	97: curses.COLOR_WHITE    # Bright White
+}
 # ------------ Exportable Help Functions ----------------
 # check if command sshpass is available
 _binPaths = {}
@@ -998,9 +1028,6 @@ def __expand_hostnames(hosts) -> dict:
 			username, host = host.split('@',1)
 			username = username.strip()
 			host = host.strip()
-			username, host = host.split('@',1)
-			username = username.strip()
-			host = host.strip()
 		# first we check if the hostname is an range of IP addresses
 		# This is done by checking if the hostname follows four fields of 
 		# "(((\d{1,3}|x|\*|\?)(-(\d{1,3}|x|\*|\?))?)|(\[(\d{1,3}|x|\*|\?)(-(\d{1,3}|x|\*|\?))?\]))" 
@@ -1059,10 +1086,10 @@ def __handle_reading_stream(stream,target, host):
 		if not keepLastLine:
 			target.pop()
 			host.output.pop()
-			host.printedLines -= 1
 		current_line_str = current_line.decode('utf-8',errors='backslashreplace')
 		target.append(current_line_str)
 		host.output.append(current_line_str)
+		host.lineNumToReprintSet.add(len(host.output)-1)
 		host.lastUpdateTime = time.time()
 	current_line = bytearray()
 	lastLineCommited = True
@@ -1329,12 +1356,13 @@ def run_command(host, sem, timeout=60,passwds=None):
 							# remove last line if it is a countdown
 							if host.output and timeoutLineAppended and host.output[-1].strip().endswith('] seconds!') and host.output[-1].strip().startswith('Timeout in ['):
 								host.output.pop()
-								host.printedLines -= 1
 							host.output.append(timeoutLine)
+							host.lineNumToReprintSet.add(len(host.output)-1)
 							timeoutLineAppended = True
 					elif host.output and timeoutLineAppended and host.output[-1].strip().endswith('] seconds!') and host.output[-1].strip().startswith('Timeout in ['):
 						host.output.pop()
-						host.printedLines -= 1
+						host.output.append('')
+						host.lineNumToReprintSet.add(len(host.output)-1)
 						timeoutLineAppended = False
 				if _emo:
 					host.stderr.append('Ctrl C detected, Emergency Stop!')
@@ -1424,6 +1452,302 @@ def start_run_on_hosts(hosts, timeout=60,password=None,max_connections=4 * os.cp
 	return threads
 
 # ------------ Display Block ----------------
+def __approximate_color_8bit(color):
+	"""
+	Approximate an 8-bit color (0-255) to the nearest curses color.
+
+	Args:
+		color: 8-bit color code
+
+	Returns:
+		Curses color code
+	"""
+	if color < 8:  # Standard and bright colors
+		return ANSI_TO_CURSES_COLOR.get(color % 8 + 30, curses.COLOR_WHITE)
+	elif 8 <= color < 16:  # Bright colors
+		return ANSI_TO_CURSES_COLOR.get(color % 8 + 90, curses.COLOR_WHITE)
+	elif 16 <= color <= 231:  # Color cube
+		# Convert 216-color cube index to RGB
+		color -= 16
+		r = (color // 36) % 6 * 51
+		g = (color // 6) % 6 * 51
+		b = color % 6 * 51
+		return __approximate_color_24bit(r, g, b)  # Map to the closest curses color
+	elif 232 <= color <= 255:  # Grayscale
+		gray = (color - 232) * 10 + 8
+		return __approximate_color_24bit(gray, gray, gray)
+	else:
+		return curses.COLOR_WHITE  # Fallback to white for unexpected values
+
+def __approximate_color_24bit(r, g, b):
+	"""
+	Approximate a 24-bit RGB color to the nearest curses color.
+	Will initiate a curses color if curses.can_change_color() is True.
+
+	Globals:
+		__curses_color_table: Dictionary of RGB color to curses color code
+		__curses_current_color_index: Current index of the
+
+	Args:
+		r: Red component (0-255)
+		g: Green component (0-255)
+		b: Blue component (0-255)
+
+	Returns:
+		Curses color code
+	"""
+	if curses.can_change_color():
+		global __curses_color_table,__curses_current_color_index
+		# Initiate a new color if it does not exist
+		if (r, g, b) not in __curses_color_table:
+			if __curses_current_color_index >= curses.COLORS:
+				eprint("Warning: Maximum number of colors reached. Wrapping around.")
+				__curses_current_color_index = 10
+			curses.init_color(__curses_current_color_index, int(r/255*1000), int(g/255*1000), int(b/255*1000))
+			__curses_color_table[(r, g, b)] = __curses_current_color_index
+			__curses_current_color_index += 1
+		return __curses_color_table[(r, g, b)]
+	# Fallback to 8-bit color approximation
+	colors = {
+		curses.COLOR_BLACK: (0, 0, 0),
+		curses.COLOR_RED: (255, 0, 0),
+		curses.COLOR_GREEN: (0, 255, 0),
+		curses.COLOR_YELLOW: (255, 255, 0),
+		curses.COLOR_BLUE: (0, 0, 255),
+		curses.COLOR_MAGENTA: (255, 0, 255),
+		curses.COLOR_CYAN: (0, 255, 255),
+		curses.COLOR_WHITE: (255, 255, 255),
+	}
+	best_match = curses.COLOR_WHITE
+	min_distance = float("inf")
+	for color, (cr, cg, cb) in colors.items():
+		distance = math.sqrt((r - cr) ** 2 + (g - cg) ** 2 + (b - cb) ** 2)
+		if distance < min_distance:
+			min_distance = distance
+			best_match = color
+	return best_match
+
+def __get_curses_color_pair(fg, bg):
+	"""
+	Use curses color int values to create a curses color pair.
+
+	Globals:
+		__curses_global_color_pairs: Dictionary of color pairs
+		__curses_current_color_pair_index: Current index of the color pair
+
+	Args:
+		fg: Foreground color code
+		bg: Background color code
+
+	Returns:
+		Curses color pair code
+	"""
+	global __curses_global_color_pairs, __curses_current_color_pair_index
+	if (fg, bg) not in __curses_global_color_pairs:
+		if __curses_current_color_pair_index >= curses.COLOR_PAIRS:
+			print("Warning: Maximum number of color pairs reached, wrapping around.")
+			__curses_current_color_pair_index = 1
+		curses.init_pair(__curses_current_color_pair_index, fg, bg)
+		__curses_global_color_pairs[(fg, bg)] = __curses_current_color_pair_index
+		__curses_current_color_pair_index += 1
+	return curses.color_pair(__curses_global_color_pairs[(fg, bg)])
+
+def __parse_ansi_escape_sequence_to_curses_attr(escape_code,color_pair_list = None):
+	"""
+	Parse ANSI escape codes to extract foreground and background colors.
+
+	Args:
+		escape_code: ANSI escape sequence for color
+		color_pair_list: List of [foreground, background, color_pair] curses color pair values
+
+	Returns:
+		Curses color pair / attribute code
+	"""
+	if not escape_code:
+		return 1
+	if not color_pair_list:
+		color_pair_list = [-1,-1,1]
+	color_match = escape_code.lstrip("\x1b[").rstrip("m").split(";")
+	color_match = [x if x else '0' for x in color_match]  # Replace empty strings with '0' (reset)
+	if color_match:
+		processed_index = -1
+		for i, param in enumerate(color_match):
+			if processed_index >= i:
+				# if the index has been processed, skip
+				continue
+			if param.isdigit():
+				if int(param) == 0:
+					color_pair_list[0] = -1
+					color_pair_list[1] = -1
+					color_pair_list[2] = 1
+				elif int(param) == 38:
+					if i + 1 >= len(color_match):
+						# Invalid color code, skip
+						continue
+					if color_match[i + 1] == "5":
+						# 8-bit foreground color
+						if i + 2 >= len(color_match) or not color_match[i + 2].isdigit():
+							# Invalid color code, skip
+							processed_index = i + 1
+							continue
+						color_pair_list[0] = __approximate_color_8bit(int(color_match[i + 2]))
+						color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+						processed_index = i + 2
+					elif color_match[i + 1] == "2":
+						# 24-bit foreground color
+						if i + 4 >= len(color_match) or not all(x.isdigit() for x in color_match[i + 2:i + 5]):
+							# Invalid color code, skip
+							processed_index = i + 1
+							continue
+						color_pair_list[0] = __approximate_color_24bit(int(color_match[i + 2]), int(color_match[i + 3]), int(color_match[i + 4]))
+						color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+						processed_index = i + 4
+				elif int(param) == 48:
+					if i + 1 >= len(color_match):
+						# Invalid color code, skip
+						continue
+					if color_match[i + 1] == "5":
+						# 8-bit background color
+						if i + 2 >= len(color_match) or not color_match[i + 2].isdigit():
+							# Invalid color code, skip
+							processed_index = i + 1
+							continue
+						color_pair_list[1] = __approximate_color_8bit(int(color_match[i + 2]))
+						color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+						processed_index = i + 2
+					elif color_match[i + 1] == "2":
+						# 24-bit background color
+						if i + 4 >= len(color_match) or not all(x.isdigit() for x in color_match[i + 2:i + 5]):
+							# Invalid color code, skip
+							processed_index = i + 1
+							continue
+						color_pair_list[1] = __approximate_color_24bit(int(color_match[i + 2]), int(color_match[i + 3]), int(color_match[i + 4]))
+						color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+						processed_index = i + 4
+				elif 30 <= int(param) <= 37 or 90 <= int(param) <= 97:
+					# 4-bit foreground color
+					color_pair_list[0] = ANSI_TO_CURSES_COLOR.get(int(param), curses.COLOR_WHITE)
+					color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+				elif 40 <= int(param) <= 47 or 100 <= int(param) <= 107:
+					# 4-bit background color
+					color_pair_list[1] = ANSI_TO_CURSES_COLOR.get(int(param)-10, curses.COLOR_BLACK)
+					color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+				elif int(param) == 1:
+					color_pair_list[2] = color_pair_list[2] | curses.A_BOLD
+				elif int(param) == 2:
+					color_pair_list[2] = color_pair_list[2] | curses.A_DIM
+				elif int(param) == 4:
+					color_pair_list[2] = color_pair_list[2] | curses.A_UNDERLINE
+				elif int(param) == 5:
+					color_pair_list[2] = color_pair_list[2] | curses.A_BLINK
+				elif int(param) == 7:
+					color_pair_list[2] = color_pair_list[2] | curses.A_REVERSE
+				elif int(param) == 8:
+					color_pair_list[2] = color_pair_list[2] | curses.A_INVIS
+				elif int(param) == 21:
+					color_pair_list[2] = color_pair_list[2] & ~curses.A_BOLD
+				elif int(param) == 22:
+					color_pair_list[2] = color_pair_list[2] & ~curses.A_DIM
+				elif int(param) == 24:
+					color_pair_list[2] = color_pair_list[2] & ~curses.A_UNDERLINE
+				elif int(param) == 25:
+					color_pair_list[2] = color_pair_list[2] & ~curses.A_BLINK
+				elif int(param) == 27:
+					color_pair_list[2] = color_pair_list[2] & ~curses.A_REVERSE
+				elif int(param) == 28:
+					color_pair_list[2] = color_pair_list[2] & ~curses.A_INVIS
+				elif int(param) == 39:
+					color_pair_list[0] = -1
+					color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+				elif int(param) == 49:
+					color_pair_list[1] = -1
+					color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+	else:
+		color_pair_list[0] = -1
+		color_pair_list[1] = -1
+		color_pair_list[2] = 1
+	return color_pair_list[2]
+
+def _curses_add_string_to_window(window, line = '', y = 0, x = 0, number_of_char_to_write = -1, color_pair_list = [-1,-1,1],fill_char=' ',parse_ansi_colors = True,centered = False,lead_str = '', trail_str = '',box_ansi_color = None, keep_top_n_lines = 0):
+	"""
+	Add a string to a curses window with / without ANSI color escape sequences translated to curses color pairs.
+
+	Args:
+		window: curses window object
+		line: The line to add
+		y: Line position in the window. Use -1 to scroll the window up 1 line and add the line at the bottom
+		x: Column position in the window
+		number_of_char_to_write: Number of characters to write. -1 for all remaining space in line, 0 for no characters, and a positive integer for a specific number of characters.
+		color_pair_list: List of [foreground, background, color_pair] curses color pair values
+		fill_char: Character to fill the remaining space in the line
+		parse_ansi_colors: Parse ASCII color codes
+		centered: Center the text in the window
+		lead_str: Leading string to add to the line
+		trail_str: Trailing string to add to the line
+		box_ansi_color: ANSI color escape sequence for the box color
+		keep_top_n_lines: Number of lines to keep at the top of the window
+	
+	Returns:
+		None
+	"""
+	if window.getmaxyx()[0] == 0 or window.getmaxyx()[1] == 0 or x >= window.getmaxyx()[1]:
+		return
+	if x < 0:
+		x = window.getmaxyx()[1] + x
+	if number_of_char_to_write == -1:
+		numChar = window.getmaxyx()[1] - x -1
+	elif number_of_char_to_write == 0:
+		return
+	elif number_of_char_to_write + x > window.getmaxyx()[1]:
+		numChar = window.getmaxyx()[1] - x -1
+	else:
+		numChar = number_of_char_to_write
+	if numChar < 0:
+		return
+	if y < 0 or  y >= window.getmaxyx()[0]:
+		if keep_top_n_lines > window.getmaxyx()[0] -1:
+			keep_top_n_lines = window.getmaxyx()[0] -1
+		if keep_top_n_lines < 0:
+			keep_top_n_lines = 0
+		window.move(keep_top_n_lines,0)
+		window.deleteln()
+		y = window.getmaxyx()[0] - 1
+	line = line.replace('\n', ' ').replace('\r', ' ')
+	if parse_ansi_colors:
+		segments = re.split(r"(\x1b\[[\d;]*m)", line)  # Split line by ANSI escape codes
+	else:
+		segments = [line]
+	charsWritten = 0
+	boxAttr = __parse_ansi_escape_sequence_to_curses_attr(box_ansi_color)
+	# first add the lead_str
+	window.addnstr(y, x, lead_str, numChar, boxAttr)
+	charsWritten = min(len(lead_str), numChar)
+	# process centering
+	if centered:
+		fill_length = numChar - len(lead_str) - len(trail_str) - sum([len(segment) for segment in segments if not segment.startswith("\x1b[")])
+		window.addnstr(y, x + charsWritten, fill_char * (fill_length // 2), numChar - charsWritten, boxAttr)
+		charsWritten += min(fill_length // 2, numChar - charsWritten)
+	# add the segments
+	for segment in segments:
+		if not segment:
+			continue
+		if parse_ansi_colors and segment.startswith("\x1b["):
+			# Parse ANSI escape sequence
+			newAttr = __parse_ansi_escape_sequence_to_curses_attr(segment,color_pair_list)
+		else:
+			# Add text with current color
+			if charsWritten < numChar:
+				window.addnstr(y, x + charsWritten, segment, numChar - charsWritten, color_pair_list[2])
+				charsWritten += min(len(segment), numChar - charsWritten)
+	# if we have finished printing segments but we still have space, we will fill it with fill_char
+	if charsWritten + len(trail_str) < numChar:
+		fillStr = fill_char * (numChar - charsWritten - len(trail_str))
+		#fillStr = f'{color_pair_list}'
+		window.addnstr(y, x + charsWritten, fillStr + trail_str, numChar - charsWritten, boxAttr)
+		charsWritten += numChar - charsWritten
+	else:
+		window.addnstr(y, x + charsWritten, trail_str, numChar - charsWritten, boxAttr)
+
 def _get_hosts_to_display (hosts, max_num_hosts, hosts_to_display = None):
 	'''
 	Generate a list for the hosts to be displayed on the screen. This is used to display as much relevant information as possible.
@@ -1458,6 +1782,7 @@ def _get_hosts_to_display (hosts, max_num_hosts, hosts_to_display = None):
 
 def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,single_window=DEFAULT_SINGLE_WINDOW, config_reason= 'New Configuration'):
 	try:
+		box_ansi_color = None
 		org_dim = stdscr.getmaxyx()
 		new_configured = True
 		# To do this, first we need to know the size of the terminal
@@ -1510,7 +1835,6 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 
 		old_stat = ''
 		old_bottom_stat = ''
-		old_cursor_position = -1
 		# we refresh the screen every 0.1 seconds
 		last_refresh_time = time.perf_counter()
 		stdscr.clear()
@@ -1519,6 +1843,7 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 		stdscr.nodelay(True)
 		# we generate a stats window at the top of the screen
 		stat_window = curses.newwin(1, max_x, 0, 0)
+		stat_window.leaveok(True)
 		# We create a window for each host
 		host_windows = []
 		for i, host in enumerate(hosts_to_display):
@@ -1529,13 +1854,18 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 			#print(f"Creating a window at {y},{x}")
 			# We create the window
 			host_window = curses.newwin(host_window_height, host_window_width, y, x)
+			host_window.idlok(True)
+			host_window.scrollok(True)
+			host_window.leaveok(True)
 			host_windows.append(host_window)
 		# If there is space left, we will draw the bottom border
 		bottom_border = None
 		if y + host_window_height  < org_dim[0]:
 			bottom_border = curses.newwin(1, max_x, y + host_window_height, 0)
+			bottom_border.leaveok(True)
 			#bottom_border.clear()
-			bottom_border.addstr(0, 0, '-' * (max_x - 1))
+			#bottom_border.addnstr(0, 0, '-' * (max_x - 1), max_x - 1)
+			_curses_add_string_to_window(window=bottom_border, y=0, line='-' * (max_x - 1),fill_char='-',box_ansi_color=box_ansi_color)
 			bottom_border.refresh()
 		while host_stats['running'] > 0 or host_stats['waiting'] > 0:
 			# Check for keypress
@@ -1626,38 +1956,40 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 				return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal resize detected')
 			# We generate the aggregated stats if user did not input anything
 			if not __keyPressesIn[lineToDisplay]:
-				stats = '┍'+ f" Total: {len(hosts)} Running: {host_stats['running']} Failed: {host_stats['failed']} Finished: {host_stats['finished']} Waiting: {host_stats['waiting']}  ww: {min_char_len} wh:{min_line_len} "[:max_x - 2].center(max_x - 2, "━")
+				#stats = '┍'+ f" Total: {len(hosts)} Running: {host_stats['running']} Failed: {host_stats['failed']} Finished: {host_stats['finished']} Waiting: {host_stats['waiting']}  ww: {min_char_len} wh:{min_line_len} "[:max_x - 2].center(max_x - 2, "━")
+				stats = f"Total: {len(hosts)} Running: {host_stats['running']} Failed: {host_stats['failed']} Finished: {host_stats['finished']} Waiting: {host_stats['waiting']}  ww: {min_char_len} wh:{min_line_len} "
 			else:
 				# we use the stat bar to display the key presses
 				encodedLine = ''.join(__keyPressesIn[lineToDisplay]).encode().decode().strip('\n') + ' '
-				# # add the flashing indicator at the curse position
-				# if time.perf_counter() % 1 > 0.5:
-				#     encodedLine = encodedLine[:curserPosition] + '█' + encodedLine[curserPosition:]
+				#stats = '┍'+ f"Send CMD: {encodedLine}"[:max_x - 2].center(max_x - 2, "━")
+				stats = f"Send CMD: {encodedLine}"
+				# format the stats line with chracter at curser position inverted using ansi escape sequence
+				stats = f'{stats[:curserPosition]}\x1b[7m{stats[curserPosition]}\x1b[0m{stats[curserPosition + 1:]}'
+			if stats != old_stat :
+				old_stat = stats
+				# calculate the real curser position in stats as we centered the stats
+				# if 'Send CMD: ' in stats:
+				# 	curserPositionStats = min(min(curserPosition,len(encodedLine) -1) + stats.find('Send CMD: ')+len('Send CMD: '), max_x -2)
 				# else:
-				#     encodedLine = encodedLine[:curserPosition] + ' ' + encodedLine[curserPosition:]
-				stats = '┍'+ f"Send CMD: {encodedLine}"[:max_x - 2].center(max_x - 2, "━")
+				# 	curserPositionStats = max_x -2
+				#stat_window.clear()
+				#stat_window.addstr(0, 0, stats)
+				# add the line with curser that inverses the color at the curser position
+				# stat_window.addstr(0, 0, stats[:curserPositionStats])
+				# stat_window.addch(0,curserPositionStats, stats[curserPositionStats], curses.A_REVERSE)
+				# stat_window.addnstr(0, curserPositionStats + 1, stats[curserPositionStats + 1:], max_x - 1 - curserPositionStats)
+				# stat_window.refresh()
+				_curses_add_string_to_window(window=stat_window, y=0, line=stats, color_pair_list=[-1, -1, 1],centered=True,fill_char='━',lead_str='┍',box_ansi_color=box_ansi_color)
 			if bottom_border:
-				bottom_stats = '└'+ f" Total: {len(hosts)} Running: {host_stats['running']} Failed: {host_stats['failed']} Finished: {host_stats['finished']} Waiting: {host_stats['waiting']} "[:max_x - 2].center(max_x - 2, "─")
+				#target_length = max_x - 2 + len('\x1b[33m\x1b[0m\x1b[31m\x1b[0m\x1b[32m\x1b[0m')
+				#bottom_stats = '└'+ f" Total: {len(hosts)} Running: \x1b[33m{host_stats['running']}\x1b[0m Failed: \x1b[31m{host_stats['failed']}\x1b[0m Finished: \x1b[32m{host_stats['finished']}\x1b[0m Waiting: {host_stats['waiting']} "[:target_length].center(target_length, "─")
+				bottom_stats = f" Total: {len(hosts)} Running: \x1b[33m{host_stats['running']}\x1b[0m Failed: \x1b[31m{host_stats['failed']}\x1b[0m Finished: \x1b[32m{host_stats['finished']}\x1b[0m Waiting: {host_stats['waiting']} "
 				if bottom_stats != old_bottom_stat:
 					old_bottom_stat = bottom_stats
 					#bottom_border.clear()
-					bottom_border.addstr(0, 0, bottom_stats)
+					#bottom_border.addnstr(0, 0, bottom_stats, max_x - 1)
+					_curses_add_string_to_window(window=bottom_border, y=0, line=bottom_stats,fill_char='─',centered=True,lead_str='└',box_ansi_color=box_ansi_color)
 					bottom_border.refresh()
-			if stats != old_stat or curserPosition != old_cursor_position:
-				old_stat = stats
-				old_cursor_position = curserPosition
-				# calculate the real curser position in stats as we centered the stats
-				if 'Send CMD: ' in stats:
-					curserPositionStats = min(min(curserPosition,len(encodedLine) -1) + stats.find('Send CMD: ')+len('Send CMD: '), max_x -2)
-				else:
-					curserPositionStats = max_x -2
-				#stat_window.clear()
-				#stat_window.addstr(0, 0, stats)
-				# add the line with curser that inverses the color at the curser position
-				stat_window.addstr(0, 0, stats[:curserPositionStats], curses.color_pair(1))
-				stat_window.addstr(0, curserPositionStats, stats[curserPositionStats], curses.color_pair(2))
-				stat_window.addstr(0, curserPositionStats + 1, stats[curserPositionStats + 1:], curses.color_pair(1))
-				stat_window.refresh()
 			# set the maximum refresh rate to 100 Hz
 			if time.perf_counter() - last_refresh_time < 0.01:
 				time.sleep(max(0,0.01 - time.perf_counter() + last_refresh_time))
@@ -1669,18 +2001,27 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 					try:
 						#host_window.clear()
 						# we will try to center the name of the host with ┼ at the beginning and end and ─ in between
-						linePrintOut = f'┼{(host.name+":["+host.command+"]")[:host_window_width - 2].center(host_window_width - 1, "─")}'.replace('\n', ' ').replace('\r', ' ').strip()
-						host_window.addstr(0, 0, linePrintOut)
+						#linePrintOut = f'┼{(host.name+":["+host.command+"]")[:host_window_width - 2].center(host_window_width - 1, "─")}'.replace('\n', ' ').replace('\r', ' ').strip()
+						#linePrintOut = f'┼{(host.name+":["+host.command+"]")[:host_window_width - 2].center(host_window_width - 1, "─")}'.replace('\n', ' ').replace('\r', ' ').strip()
+						#host_window.addnstr(0, 0, linePrintOut, host_window_width - 1)
+						linePrintOut = f'{host.name}:[{host.command}]'.replace('\n', ' ').replace('\r', ' ').strip()
+						_curses_add_string_to_window(window=host_window, y=0, line=linePrintOut, color_pair_list=[-1, -1, 1],centered=True,fill_char='─',lead_str='┼',box_ansi_color=box_ansi_color)
+						#_add_line_with_ansi_colors(window=host_window, y=0, x=0, line=linePrintOut, n=host_window_width - 1, color_pair_list = host.current_color_pair)
 						# we will display the latest outputs of the host as much as we can
-						for i, line in enumerate(host.output[-(host_window_height - 1):]):
+						#for i, line in enumerate(host.output[-(host_window_height - 1):]):
 							# print(f"Printng a line at {i + 1} with length of {len('│'+line[:host_window_width - 1])}")
 							# time.sleep(10)
-							linePrintOut = ('│'+line[:host_window_width - 2].replace('\n', ' ').replace('\r', ' ')).strip().ljust(host_window_width - 1, ' ')
-							host_window.addstr(i + 1, 0, linePrintOut)
+							#linePrintOut = ('│'+line[:host_window_width - 2].replace('\n', ' ').replace('\r', ' ')).strip()
+							#host_window.addnstr(i + 1, 0, linePrintOut, host_window_width - 1)
+							#_curses_add_string_to_window(window=host_window, y=i + 1, line=line, color_pair_list=host.current_color_pair,lead_str='│')
 						# we draw the rest of the available lines
+						# for i in range(len(host.output), host_window_height - 1):
+						# 	# print(f"Printng a line at {i + 1} with length of {len('│')}")
+						# 	host_window.addnstr(i + 1, 0, '│'.ljust(host_window_width - 1, ' '), host_window_width - 1)
+						for i in range(host.printedLines, len(host.output)):
+							_curses_add_string_to_window(window=host_window, y=i + 1, line=host.output[i], color_pair_list=host.current_color_pair,lead_str='│',keep_top_n_lines=1,box_ansi_color=box_ansi_color)
 						for i in range(len(host.output), host_window_height - 1):
-							# print(f"Printng a line at {i + 1} with length of {len('│')}")
-							host_window.addstr(i + 1, 0, '│'.ljust(host_window_width - 1, ' '))
+							_curses_add_string_to_window(window=host_window, y=i + 1,lead_str='│',keep_top_n_lines=1,box_ansi_color=box_ansi_color)
 						host.printedLines = len(host.output)
 						host_window.refresh()
 					except Exception as e:
@@ -1689,6 +2030,24 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 						# print(traceback.format_exc().strip())
 						if org_dim != stdscr.getmaxyx():
 							return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal resize detected')
+				if host.lineNumToReprintSet:
+					# visible range is from host.printedLines - host_window_height + 1 to host.printedLines
+					visibleLowerBound = host.printedLines - host_window_height + 1
+					for lineNumToReprint in host.lineNumToReprintSet:
+						# if the line is visible, we will reprint it
+						if visibleLowerBound <= lineNumToReprint <= host.printedLines:
+							if visibleLowerBound <= 0:
+								# this means all lines are visible
+								linePos = lineNumToReprint
+							else:
+								# calculate the position of the line to reprint
+								linePos = lineNumToReprint - visibleLowerBound
+							# Note: color can be incorrect if repainting an old line with new colors already initialized,
+							# 	 Thus we will not use any presistent color pair for old lines
+							cpl = host.current_color_pair if lineNumToReprint == host.printedLines else [-1,-1,1]
+							_curses_add_string_to_window(window=host_window, y=linePos + 1, line=host.output[lineNumToReprint], color_pair_list=cpl,lead_str='│',keep_top_n_lines=1,box_ansi_color=box_ansi_color)
+					host.lineNumToReprintSet = set()
+					host_window.refresh()
 			new_configured = False
 			last_refresh_time = time.perf_counter()
 	except Exception as e:
@@ -1710,33 +2069,39 @@ def curses_print(stdscr, hosts, threads, min_char_len = DEFAULT_CURSES_MINIMUM_C
 	'''
 	# We create all the windows we need
 	# We initialize the color pair
-	curses.start_color()
 	curses.curs_set(0)
-	curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
-	curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_WHITE)
-	curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK)
-	curses.init_pair(4, curses.COLOR_GREEN, curses.COLOR_BLACK)
-	curses.init_pair(5, curses.COLOR_YELLOW, curses.COLOR_BLACK)
-	curses.init_pair(6, curses.COLOR_BLUE, curses.COLOR_BLACK)
-	curses.init_pair(7, curses.COLOR_MAGENTA, curses.COLOR_BLACK)
-	curses.init_pair(8, curses.COLOR_CYAN, curses.COLOR_BLACK)
-	curses.init_pair(9, curses.COLOR_WHITE, curses.COLOR_RED)
-	curses.init_pair(10, curses.COLOR_WHITE, curses.COLOR_GREEN)
-	curses.init_pair(11, curses.COLOR_WHITE, curses.COLOR_YELLOW)
-	curses.init_pair(12, curses.COLOR_WHITE, curses.COLOR_BLUE)
-	curses.init_pair(13, curses.COLOR_WHITE, curses.COLOR_MAGENTA)
-	curses.init_pair(14, curses.COLOR_WHITE, curses.COLOR_CYAN)
-	curses.init_pair(15, curses.COLOR_BLACK, curses.COLOR_RED)
-	curses.init_pair(16, curses.COLOR_BLACK, curses.COLOR_GREEN)
-	curses.init_pair(17, curses.COLOR_BLACK, curses.COLOR_YELLOW)
-	curses.init_pair(18, curses.COLOR_BLACK, curses.COLOR_BLUE)
-	curses.init_pair(19, curses.COLOR_BLACK, curses.COLOR_MAGENTA)
-	curses.init_pair(20, curses.COLOR_BLACK, curses.COLOR_CYAN)
-
+	curses.start_color()
+	curses.use_default_colors()
+	curses.init_pair(1, -1, -1)
 	# do not generate display if the output window have a size of zero
 	if stdscr.getmaxyx()[0] < 2 or stdscr.getmaxyx()[1] < 2:
 		return
-
+	stdscr.idlok(True)
+	stdscr.scrollok(True)
+	stdscr.leaveok(True)
+	# generate some debug information before display initialization
+	try:
+		stdscr.clear()
+		_curses_add_string_to_window(window=stdscr, y=0, line='Initializing display...', n=stdscr.getmaxyx()[1] - 1)
+		# print the size
+		_curses_add_string_to_window(window=stdscr, y=1, line=f"Terminal size: {stdscr.getmaxyx()}", n=stdscr.getmaxyx()[1] - 1)
+		# print the number of hosts
+		_curses_add_string_to_window(window=stdscr, y=2, line=f"Number of hosts: {len(hosts)}", n=stdscr.getmaxyx()[1] - 1)
+		# print the number of threads
+		_curses_add_string_to_window(window=stdscr, y=3, line=f"Number of threads: {len(threads)}", n=stdscr.getmaxyx()[1] - 1)
+		# print the minimum character length
+		_curses_add_string_to_window(window=stdscr, y=4, line=f"Minimum character length: {min_char_len}", n=stdscr.getmaxyx()[1] - 1)
+		# print the minimum line length
+		_curses_add_string_to_window(window=stdscr, y=5, line=f"Minimum line length: {min_line_len}", n=stdscr.getmaxyx()[1] - 1)
+		# print the single window mode
+		_curses_add_string_to_window(window=stdscr, y=6, line=f"Single window mode: {single_window}", n=stdscr.getmaxyx()[1] - 1)
+		# print COLORS and COLOR_PAIRS count
+		_curses_add_string_to_window(window=stdscr, y=7, line=f"len(COLORS): {curses.COLORS} len(COLOR_PAIRS): {curses.COLOR_PAIRS}", n=stdscr.getmaxyx()[1] - 1)
+		# print if can change color
+		_curses_add_string_to_window(window=stdscr, y=8, line=f"Real color capability: {curses.can_change_color()}", n=stdscr.getmaxyx()[1] - 1)
+		stdscr.refresh()
+	except:
+		pass
 	params = (-1,0 , min_char_len, min_line_len, single_window,'new config')
 	while params:
 		params = __generate_display(stdscr, hosts, *params)

{multissh3-5.27 → multissh3-5.33}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup
 
 setup(
     name='multiSSH3',
-    version='5.27',
+    version='5.33',
     description='Run commands on multiple hosts via SSH',
     long_description=open('README.md').read(),
     long_description_content_type='text/markdown',