multiSSH3 5.27__tar.gz → 5.30__tar.gz

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

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

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

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

{multissh3-5.27 → multissh3-5.30}/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.30'
 VERSION = version
 
 CONFIG_FILE = '/etc/multiSSH3.config.json'	
@@ -179,12 +180,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}, 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 +347,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 +1027,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|\*|\?))?\]))" 
@@ -1424,6 +1450,227 @@ 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 __parse_ansi_escape_sequence_to_curses_color(escape_code):
+	"""
+	Parse ANSI escape codes to extract foreground and background colors.
+
+	Args:
+		escape_code: ANSI escape sequence for color
+
+	Returns:
+		Tuple of (foreground, background) curses color pairs. 
+		If the escape code is a reset code, return (-1, -1).
+		None values indicate that the color should not be changed.
+	"""
+	if not escape_code:
+		return None, None
+	color_match = re.match(r"\x1b\[(\d+)(?:;(\d+))?(?:;(\d+))?(?:;(\d+);(\d+);(\d+))?m", escape_code)
+	if color_match:
+		params = color_match.groups()
+		if params[0] == "0" and not any(params[1:]):  # Reset code
+			return -1, -1
+		if params[0] == "38" and params[1] == "5":  # 8-bit foreground
+			return __approximate_color_8bit(int(params[2])), None
+		elif params[0] == "38" and params[1] == "2":  # 24-bit foreground
+			return __approximate_color_24bit(int(params[3]), int(params[4]), int(params[5])), None
+		elif params[0] == "48" and params[1] == "5":  # 8-bit background
+			return None , __approximate_color_8bit(int(params[2]))
+		elif params[0] == "48" and params[1] == "2":  # 24-bit background
+			return None, __approximate_color_24bit(int(params[3]), int(params[4]), int(params[5]))
+		else:
+			fg = None
+			bg = None
+			if params[0] and params[0].isdigit():  # 4-bit color
+				fg = ANSI_TO_CURSES_COLOR.get(int(params[0]), curses.COLOR_WHITE)
+			if params[1] and params[1].isdigit():
+				bg = ANSI_TO_CURSES_COLOR.get(int(params[1]), curses.COLOR_BLACK)
+			return fg, bg
+	return None, None
+
+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 _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_ascii_colors = True,centered = False,lead_str = '', trail_str = '',box_ansi_color = None):
+	"""
+	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_ascii_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
+	
+	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]:
+		window.move(0, 0)
+		window.deleteln()
+		y = window.getmaxyx()[0] - 1
+	if parse_ascii_colors:
+		segments = re.split(r"(\x1b\[[\d;]*m)", line)  # Split line by ANSI escape codes
+	else:
+		segments = [line]
+	charsWritten = 0
+	boxFrontColor, boxBackColor = color_pair_list[0], color_pair_list[1]
+	newBoxFrontColor, newBoxBackColor = __parse_ansi_escape_sequence_to_curses_color(box_ansi_color)
+	if newBoxFrontColor:
+		boxFrontColor = newBoxFrontColor
+	if newBoxBackColor:
+		boxBackColor = newBoxBackColor
+	boxColorPair = __get_curses_color_pair(boxFrontColor, boxBackColor)
+	# first add the lead_str
+	window.addnstr(y, x, lead_str, numChar, boxColorPair)
+	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, boxColorPair)
+		charsWritten += min(fill_length // 2, numChar - charsWritten)
+	# add the segments
+	for segment in segments:
+		if parse_ascii_colors and segment.startswith("\x1b["):
+			# Parse ANSI escape sequence
+			newFrontColor, newBackColor = __parse_ansi_escape_sequence_to_curses_color(segment)
+			if newFrontColor is not None:
+				color_pair_list[0] = newFrontColor
+			if newBackColor is not None:
+				color_pair_list[1] = newBackColor
+			color_pair_list[2] = __get_curses_color_pair(color_pair_list[0], color_pair_list[1])
+			#window.addnstr(y, x + charsWritten, str(color_pair_list[2]), numChar - charsWritten, color_pair_list[2])
+			#charsWritten += min(len(str(color_pair_list[2])), numChar - charsWritten)
+		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, boxColorPair)
+		charsWritten += numChar - charsWritten
+	else:
+		window.addnstr(y, x + charsWritten, trail_str, numChar - charsWritten, boxColorPair)
+
 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.
@@ -1519,6 +1766,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 +1777,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='-')
 			bottom_border.refresh()
 		while host_stats['running'] > 0 or host_stats['waiting'] > 0:
 			# Check for keypress
@@ -1637,11 +1890,13 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 				#     encodedLine = encodedLine[:curserPosition] + ' ' + encodedLine[curserPosition:]
 				stats = '┍'+ f"Send CMD: {encodedLine}"[:max_x - 2].center(max_x - 2, "━")
 			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, "─")
 				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)
 					bottom_border.refresh()
 			if stats != old_stat or curserPosition != old_cursor_position:
 				old_stat = stats
@@ -1654,9 +1909,9 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 				#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.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()
 			# set the maximum refresh rate to 100 Hz
 			if time.perf_counter() - last_refresh_time < 0.01:
@@ -1670,17 +1925,19 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 						#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)
+						host_window.addnstr(0, 0, linePrintOut, host_window_width - 1)
+						#_add_line_with_ascii_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):]):
 							# 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=linePrintOut, color_pair_list=host.current_color_pair)
 						# 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.addstr(i + 1, 0, '│'.ljust(host_window_width - 1, ' '))
+							host_window.addnstr(i + 1, 0, '│'.ljust(host_window_width - 1, ' '), host_window_width - 1)
 						host.printedLines = len(host.output)
 						host_window.refresh()
 					except Exception as e:
@@ -1710,33 +1967,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.30}/setup.py

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