multiSSH3 5.46__tar.gz → 5.48__tar.gz

{multissh3-5.46 → multissh3-5.48}/PKG-INFO

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

{multissh3-5.46 → multissh3-5.48}/multiSSH3.egg-info/PKG-INFO

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

{multissh3-5.46 → multissh3-5.48}/multiSSH3.egg-info/SOURCES.txt

@@ -6,4 +6,9 @@ multiSSH3.egg-info/SOURCES.txt
 multiSSH3.egg-info/dependency_links.txt
 multiSSH3.egg-info/entry_points.txt
 multiSSH3.egg-info/requires.txt
-multiSSH3.egg-info/top_level.txt
+multiSSH3.egg-info/top_level.txt
+test/test.py
+test/testCurses.py
+test/testCursesOld.py
+test/testPerfCompact.py
+test/testPerfExpand.py

{multissh3-5.46 → multissh3-5.48}/multiSSH3.py

@@ -34,6 +34,7 @@ import uuid
 import tempfile
 import math
 from itertools import count
+import queue
 
 try:
 	# Check if functiools.cache is available
@@ -46,7 +47,7 @@ except AttributeError:
 		# If neither is available, use a dummy decorator
 		def cache_decorator(func):
 			return func
-version = '5.46'
+version = '5.48'
 VERSION = version
 COMMIT_DATE = '2025-01-30'
 
@@ -90,31 +91,68 @@ def signal_handler(sig, frame):
 		os.system(f'pkill -ef {os.path.basename(__file__)}')
 		sys.exit(0)
 
+# def input_with_timeout_and_countdown(timeout, prompt='Please enter your selection'):
+# 	"""
+# 	Read an input from the user with a timeout and a countdown.
+
+# 	Parameters:
+# 	timeout (int): The timeout value in seconds.
+# 	prompt (str): The prompt message to display to the user. Default is 'Please enter your selection'.
+
+# 	Returns:
+# 	str or None: The user input if received within the timeout, or None if no input is received.
+# 	"""
+# 	import select
+# 	# Print the initial prompt with the countdown
+# 	eprint(f"{prompt} [{timeout}s]: ", end='', flush=True)
+# 	# Loop until the timeout
+# 	for remaining in range(timeout, 0, -1):
+# 		# If there is an input, return it
+# 		# this only works on linux
+# 		if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
+# 			return input().strip()
+# 		# Print the remaining time
+# 		eprint(f"\r{prompt} [{remaining}s]: ", end='', flush=True)
+# 		# Wait a second
+# 		time.sleep(1)
+# 	# If there is no input, return None
+# 	return None
+
 def input_with_timeout_and_countdown(timeout, prompt='Please enter your selection'):
 	"""
-	Read an input from the user with a timeout and a countdown.
-
-	Parameters:
-	timeout (int): The timeout value in seconds.
-	prompt (str): The prompt message to display to the user. Default is 'Please enter your selection'.
-
-	Returns:
-	str or None: The user input if received within the timeout, or None if no input is received.
+	Read input from the user with a timeout (cross-platform).
+	If the user does not enter any input within `timeout` seconds, return None.
+	Otherwise, return the input string.
 	"""
-	import select
-	# Print the initial prompt with the countdown
+	# Queue to receive user input from the background thread
+	input_queue = queue.Queue()
+	def read_input():
+		# Read line from stdin and put it in the queue
+		user_input = sys.stdin.readline()
+		input_queue.put(user_input)
+	# Start a thread that will block on input()
+	input_thread = threading.Thread(target=read_input, daemon=True)
+	input_thread.start()
+	# Print the initial prompt
 	eprint(f"{prompt} [{timeout}s]: ", end='', flush=True)
-	# Loop until the timeout
-	for remaining in range(timeout, 0, -1):
-		# If there is an input, return it
-		if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
-			return input().strip()
-		# Print the remaining time
+	# Countdown loop
+	start_time = time.time()
+	while True:
+		# Check if the input thread has finished (i.e., user pressed Enter)
+		if not input_queue.empty():
+			# We got user input
+			user_input = input_queue.get().strip()
+			eprint()  # move to the next line
+			return user_input
+		elapsed = int(time.time() - start_time)
+		remaining = timeout - elapsed
+		if remaining <= 0:
+			# Time is up, no input
+			eprint()  # move to the next line
+			return None
+		# Update prompt countdown
 		eprint(f"\r{prompt} [{remaining}s]: ", end='', flush=True)
-		# Wait a second
 		time.sleep(1)
-	# If there is no input, return None
-	return None
 
 @cache_decorator
 def getIP(hostname: str,local=False):
@@ -1879,7 +1917,11 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 				# with open('keylog.txt','a') as f:
 				#     f.write(str(key)+'\n')
 				if key == 410: # 410 is the key code for resize
-					return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal resize requested')      
+					return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal resize requested')    
+				# if the user pressed ctrl + d and the last line is empty, we will exit by adding 'exit\n' to the last line
+				elif key == 4 and not __keyPressesIn[-1]:
+					__keyPressesIn[-1].extend('exit\n')
+					__keyPressesIn.append([])
 				elif key == 95 and not __keyPressesIn[-1]: # 95 is the key code for _
 					# if last line is empty, we will reconfigure the wh to be smaller
 					if min_line_len != 1:

multissh3-5.48/test/test.py

@@ -0,0 +1,316 @@
+import re
+import string
+
+def validate_expand_hostname(hostname):
+	# Assuming this function is already implemented.
+	return [hostname]
+
+
+def old_expand_hostname(text,validate=True):
+	'''
+	Expand the hostname range in the text.
+	Will search the string for a range ( [] encloused and non enclosed number ranges).
+	Will expand the range, validate them using validate_expand_hostname and return a list of expanded hostnames
+
+	Args:
+		text (str): The text to be expanded
+		validate (bool, optional): Whether to validate the hostname. Defaults to True.
+
+	Returns:
+		set: A set of expanded hostnames
+	'''
+	expandinghosts = [text]
+	expandedhosts = set()
+	# all valid alphanumeric characters
+	alphanumeric = string.digits + string.ascii_letters
+	while len(expandinghosts) > 0:
+		hostname = expandinghosts.pop()
+		match = re.search(r'\[(.*?-.*?)\]', hostname)
+		if not match:
+			expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+			continue
+		try:
+			range_start, range_end = match.group(1).split('-')
+		except ValueError:
+			expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+			continue
+		range_start = range_start.strip()
+		range_end = range_end.strip()
+		if not range_end:
+			if range_start.isdigit():
+				range_end = '9'
+			elif range_start.isalpha() and range_start.islower():
+				range_end = 'z'
+			elif range_start.isalpha() and range_start.isupper():
+				range_end = 'Z'
+			else:
+				expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+				continue
+		if not range_start:
+			if range_end.isdigit():
+				range_start = '0'
+			elif range_end.isalpha() and range_end.islower():
+				range_start = 'a'
+			elif range_end.isalpha() and range_end.isupper():
+				range_start = 'A'
+			else:
+				expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+				continue
+		if range_start.isdigit() and range_end.isdigit():
+			padding_length = min(len(range_start), len(range_end))
+			format_str = "{:0" + str(padding_length) + "d}"
+			for i in range(int(range_start), int(range_end) + 1):
+				formatted_i = format_str.format(i)
+				if '[' in hostname:
+					expandinghosts.append(hostname.replace(match.group(0), formatted_i, 1))
+				else:
+					expandedhosts.update(validate_expand_hostname(hostname.replace(match.group(0), formatted_i, 1)) if validate else [hostname])
+		else:
+			if all(c in string.hexdigits for c in range_start + range_end):
+				for i in range(int(range_start, 16), int(range_end, 16)+1):
+					if '[' in hostname:
+						expandinghosts.append(hostname.replace(match.group(0), format(i, 'x'), 1))
+					else:
+						expandedhosts.update(validate_expand_hostname(hostname.replace(match.group(0), format(i, 'x'), 1)) if validate else [hostname])
+			else:
+				try:
+					start_index = alphanumeric.index(range_start)
+					end_index = alphanumeric.index(range_end)
+					for i in range(start_index, end_index + 1):
+						if '[' in hostname:
+							expandinghosts.append(hostname.replace(match.group(0), alphanumeric[i], 1))
+						else:
+							expandedhosts.update(validate_expand_hostname(hostname.replace(match.group(0), alphanumeric[i], 1)) if validate else [hostname])
+				except ValueError:
+					expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+	return expandedhosts
+
+def expand_hostname(text, validate=True):
+	'''
+	Expand the hostname range in the text.
+	Will search the string for a range ( [] enclosed and non-enclosed number ranges).
+	Will expand the range, validate them using validate_expand_hostname and return a list of expanded hostnames
+
+	Args:
+		text (str): The text to be expanded
+		validate (bool, optional): Whether to validate the hostname. Defaults to True.
+
+	Returns:
+		set: A set of expanded hostnames
+	'''
+	expandinghosts = [text]
+	expandedhosts = set()
+	# all valid alphanumeric characters
+	alphanumeric = string.digits + string.ascii_letters
+	while len(expandinghosts) > 0:
+		hostname = expandinghosts.pop()
+		match = re.search(r'\[(.*?)]', hostname)
+		if not match:
+			expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+			continue
+		group = match.group(1)
+		parts = group.split(',')
+		for part in parts:
+			part = part.strip()
+			if '-' in part:
+				try:
+					range_start,_, range_end = part.partition('-')
+				except ValueError:
+					expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+					continue
+				range_start = range_start.strip()
+				range_end = range_end.strip()
+				if range_start.isdigit() and range_end.isdigit():
+					padding_length = min(len(range_start), len(range_end))
+					format_str = "{:0" + str(padding_length) + "d}"
+					for i in range(int(range_start), int(range_end) + 1):
+						formatted_i = format_str.format(i)
+						expandinghosts.append(hostname.replace(match.group(0), formatted_i, 1))
+				elif all(c in string.hexdigits for c in range_start + range_end):
+					for i in range(int(range_start, 16), int(range_end, 16) + 1):
+						expandinghosts.append(hostname.replace(match.group(0), format(i, 'x'), 1))
+				else:
+					try:
+						start_index = alphanumeric.index(range_start)
+						end_index = alphanumeric.index(range_end)
+						for i in range(start_index, end_index + 1):
+							expandinghosts.append(hostname.replace(match.group(0), alphanumeric[i], 1))
+					except ValueError:
+						expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+			else:
+				expandinghosts.append(hostname.replace(match.group(0), part, 1))
+	return expandedhosts
+
+# Example usage
+# text = "test[2-1c]"
+# print(expand_hostname(text))
+# print(old_expand_hostname(text))
+
+# Test cases for expand_hostname and old_expand_hostname functions
+
+def run_tests():
+	test_cases = [
+		# Simple numeric range
+		("test[1-3]", {"test1", "test2", "test3"}),
+
+		# Simple letter range
+		("host[a-c]", {"hosta", "hostb", "hostc"}),
+
+		# Simple hexadecimal range
+		("hex[0-3]", {"hex0", "hex1", "hex2", "hex3"}),
+
+		# Numeric range with padding
+		("server[001-003]", {"server001", "server002", "server003"}),
+
+		# Letter and numeric mixed ranges
+		("mixed[a-b,1-2]", {"mixeda", "mixedb", "mixed1", "mixed2"}),
+
+		# Multiple ranges with different characters
+		("complex[a-c,1-2,x]", {"complexa", "complexb", "complexc", "complex1", "complex2", "complexx"}),
+
+		# Hexadecimal range with uppercase letters
+		("hexrange[A-C]", {"hexrangea", "hexrangeb", "hexrangec"}),
+
+		# Multiple numeric ranges
+		("num[1-2,5-6]", {"num1", "num2", "num5", "num6"}),
+
+		# Overlapping numeric range
+		("overlap[3-6,5-8]", {"overlap3", "overlap4", "overlap5", "overlap6", "overlap7", "overlap8"}),
+
+		# Invalid input without range brackets
+		("invalid_host", {"invalid_host"}),
+
+		# No content inside brackets
+		("empty[]", {"empty"}),
+
+		# Invalid range format with non-numeric or non-alphanumeric character
+		("invalid[@-%]", {"invalid[@-%]"}),
+
+		# No valid starting character for range
+		#("start[0-9A-Z]", {"start0", "start1", "start2", "start3", "start4", "start5", "start6", "start7", "start8", "start9"}),
+
+		# Empty input
+		("", {""}),
+
+		# Simple hostname without any ranges
+		("hostname", {"hostname"}),
+		("hostname[x-z]", {"hostnamex","hostnamey","hostnamez"}),
+
+		# Mixed valid and invalid ranges
+		#("mix[1-3, x-]", {"mix1", "mix2", "mix3", "mix[ x-]"}),
+
+		# Single digit to single letter range
+		("combo[5-a]", {'combo8', 'combo6', 'combo9', 'comboa', 'combo5', 'combo7'}),
+	]
+
+	for idx, (input_str, expected) in enumerate(test_cases):
+		result = expand_hostname(input_str, validate=False)
+		#old_result = old_expand_hostname(input_str, validate=False)
+		assert result == expected, f"Test {idx + 1} failed in expand_hostname(). Expected: {expected}, Got: {result}"
+		#assert old_result == expected, f"Test {idx + 1} failed in old_expand_hostname(). Expected: {expected}, Got: {old_result}"
+		print(f"Test {idx + 1} passed.")
+		
+import re
+
+def tokenize_hostname(hostname):
+	"""
+	Tokenize the hostname into a list of tokens.
+	Tokens will be seperated by symbols or numbers.
+
+	Args:
+		hostname (str): The hostname to tokenize.
+
+	Returns:
+		list: A list of tokens (hashed).
+	"""
+	# Split the hostname into tokens
+	tokens = re.findall(r"([a-zA-Z]+|\d+)", hostname)
+	# Hash the tokens
+	return [hash(token) for token in tokens]
+
+
+
+def compact_hostnames(hostnames):
+	patterns = defaultdict(list)
+	for hostname in hostnames:
+		parts = parse_hostname(hostname)
+		pattern = get_pattern(parts)
+		patterns[pattern].append(parts)
+	
+	# Function to compact a list of numbers
+	def compact_numbers(numbers):
+		sorted_nums = sorted(set(numbers))
+		if len(sorted_nums) == 1:
+			return str(sorted_nums[0])
+		ranges = []
+		start = prev = sorted_nums[0]
+		for number in sorted_nums[1:]:
+			if number != prev + 1:
+				if start == prev:
+					ranges.append(str(start))
+				else:
+					ranges.append(f"{start}-{prev}")
+				start = number
+			prev = number
+		if start == prev:
+			ranges.append(str(start))
+		else:
+			ranges.append(f"{start}-{prev}")
+		return "[" + ",".join(ranges) + "]"
+
+	results = []
+	for pattern, parts_list in patterns.items():
+		segment_lists = OrderedDict()
+		for parts in parts_list:
+			for i, part in enumerate(parts):
+				if part.isdigit():
+					if i not in segment_lists:
+						segment_lists[i] = []
+					segment_lists[i].append(int(part))
+		
+		# Construct the resulting compacted hostname
+		result_parts = []
+		last_index = 0
+		for index, num_list in segment_lists.items():
+			# Add the preceding static text
+			result_parts.append("".join(pattern[last_index:index]))
+			last_index = index + 1
+			# Add the compacted number range
+			result_parts.append(compact_numbers(num_list))
+		# Add any trailing static text
+		result_parts.append("".join(pattern[last_index:]))
+		results.append("".join(result_parts))
+	
+	return ",".join(results)
+
+# Test this updated function with your test cases.
+
+
+# Run the tests
+run_tests()
+
+# servera,serverb,serverc=server[a-c]
+# server15,server16,server17=server[15-17]
+# server-1,server-2,server-3=server-[1-3]
+# server-1-2,server-1-1,server-2-1,server-2-2=server-[1-2]-[1-2]
+# server-1-2,server-1-1,server-2-2=server-1-[1-2],server-2-2
+# test1-a,test2-a=test[1-2]-a
+
+# Test cases
+test_cases = [
+	(['server15', 'server16', 'server17'], 'server[15-17]'),
+	(['server-1', 'server-2', 'server-3'], 'server-[1-3]'),
+	(['server-1-2', 'server-1-1', 'server-2-1', 'server-2-2'], 'server-[1-2]-[1-2]'),
+	(['server-1-2', 'server-1-1', 'server-2-2'], 'server-1-[1-2],server-2-2'),
+	(['test1-a', 'test2-a'], 'test[1-2]-a'),
+	(['sub-s1', 'sub-s2'], 'sub-s[1-2]'),
+]
+
+for hostnames, expected in test_cases:
+	result = compact_hostnames(hostnames)
+	print(f"Hostnames: {hostnames}")
+	print(f"Compacted: {result}")
+	print(f"Expected:  {expected}")
+	print(f"Pass: {result == expected}\n")
+
+

multissh3-5.48/test/testCurses.py

@@ -0,0 +1,455 @@
+import curses
+import re
+import math
+import sys
+
+# Global dictionary to store color pairs
+__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
+}
+
+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 // len(fill_char)), numChar - charsWritten, boxAttr)
+		charsWritten += min(len(fill_char * (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))//len(fill_char))
+		#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.
+
+	Args:
+		hosts (list): A list of Host objects
+		max_num_hosts (int): The maximum number of hosts to be displayed
+		hosts_to_display (list, optional): The hosts that are currently displayed. Defaults to None.
+
+	Returns:
+		list: A list of Host objects to be displayed
+	'''
+	# We will sort the hosts by running -> failed -> finished -> waiting
+	# running: returncode is None and output is not empty (output will be appened immediately after the command is run)
+	# failed: returncode is not None and returncode is not 0
+	# finished: returncode is not None and returncode is 0
+	# waiting: returncode is None and output is empty
+	running_hosts = [host for host in hosts if host.returncode is None and host.output]
+	failed_hosts = [host for host in hosts if host.returncode is not None and host.returncode != 0]
+	finished_hosts = [host for host in hosts if host.returncode is not None and host.returncode == 0]
+	waiting_hosts = [host for host in hosts if host.returncode is None and not host.output]
+	new_hosts_to_display = (running_hosts + failed_hosts + finished_hosts + waiting_hosts)[:max_num_hosts]
+	if not hosts_to_display:
+		return new_hosts_to_display , {'running':len(running_hosts), 'failed':len(failed_hosts), 'finished':len(finished_hosts), 'waiting':len(waiting_hosts)}
+	# we will compare the new_hosts_to_display with the old one, if some hosts are not in their original position, we will change its printedLines to 0
+	for i, host in enumerate(new_hosts_to_display):
+		if host not in hosts_to_display:
+			host.printedLines = 0
+		elif i != hosts_to_display.index(host):
+			host.printedLines = 0
+	return new_hosts_to_display , {'running':len(running_hosts), 'failed':len(failed_hosts), 'finished':len(finished_hosts), 'waiting':len(waiting_hosts)}
+
+TEST_LINE = (
+		"Standard \x1b[31m          Red\x1b[0m, ",
+		"Bold \x1b[91m            \x1b[1mRed\x1b[0m, ",
+		"Standard \x1b[32m        Green\x1b[0m, ",
+		"Bright \x1b[92m          Green\x1b[0m, ",
+		"Standard \x1b[33m       Yellow\x1b[0m, ",
+		"Bright \x1b[93m          Yellow\x1b[0m, ",
+		"Standard \x1b[34m          Blue\x1b[0m, ",
+		"Bright \x1b[94m          Blue\x1b[0m, ",
+		"Standard \x1b[35m          Magenta\x1b[0m, ",
+		"Bright \x1b[95m          Magenta\x1b[0m, ",
+		"Standard \x1b[36m          Cyan\x1b[0m, ",
+		"Bright \x1b[96m          Cyan\x1b[0m, ",
+		"Standard \x1b[37m          White\x1b[0m, ",
+		"Bright \x1b[97m          White\x1b[0m, ",
+		"8-bit \x1b[38;5;196m          Red\x1b[0m, ",
+		"8-bit \x1b[38;5;82m          Green\x1b[0m, ",
+		"8-bit \x1b[38;5;27m          Blue\x1b[0m, ",
+		"8-bit \x1b[38;5;226m          Yellow\x1b[0m, ",
+		"8-bit \x1b[38;5;201m          Magenta\x1b[0m, ",
+		"8-bit \x1b[38;5;51m          Cyan\x1b[0m, ",
+		"8-bit \x1b[38;5;15m          White\x1b[0m, ",
+		"8-bit \x1b[38;5;0m          Black\x1b[0m, ",
+		"8-bit \x1b[38;5;4m          Blue\x1b[0m, ",
+		"24-bit \x1b[38;2;128;128;128m          Gray\x1b[0m.",
+		"24-bit \x1b[38;2;255;165;0m          Orange\x1b[0m.",
+		"24-bit \x1b[38;2;255;0;255m          Pink\x1b[0m.",
+		"24-bit \x1b[38;2;0;255;255m          Cyan\x1b[0m.",
+		"24-bit \x1b[38;2;255;255;255m          White\x1b[0m.",
+		"24-bit \x1b[38;2;0;0;0m          Black\x1b[0m.",
+		"24-bit \x1b[38;2;128;128;128m          Gray\x1b[0m.",
+		"24-bit \x1b[38;2;255;0;0m          Red\x1b[0m.",
+		"24-bit \x1b[38;2;0;255;0m          Green\x1b[0m.",
+		"24-bit \x1b[38;2;0;0;255m          Blue\x1b[0m.",
+		"24-bit \x1b[38;2;255;255;0m          Yellow\x1b[0m.",
+		"24-bit \x1b[38;2;255;0;255m          Magenta\x1b[0m.",
+		"24-bit \x1b[38;2;0;255;255m          Cyan colored dot.",
+		"Following string without reset color.",
+		"Following string with \x1b[31m          Red color.",
+		"Following string with \x1b[31m          Red color and \x1b[32m          Green color.",
+		"Reset color. \x1b[0m          Following string with default color.",
+		"Bold \x1b[1m          Following string with bold text.\x1b[0m",
+		"Dim \x1b[2m          Following string with dim text.\x1b[0m",
+		"Underline \x1b[4m          Following string with underline text.\x1b[0m",
+		"Blink \x1b[5m          Following string with blink text.\x1b[0m",
+		"Reverse \x1b[7m          Following string with reverse text.\x1b[0m",
+		"Invisible \x1b[8m          Following string with invisible text.\x1b[0m",
+		"Reset color. \x1b[0m          Following string with default color.\x1b[0m",
+		"Bold \x1b[1m          Following string with \x1b[22m not bold text.\x1b[0m",
+		"RedGreen \x1b[31;32m          Green\x1b[0m, ",
+	)
+# Example usage in a curses application
+def main(stdscr):
+	curses.start_color()
+	curses.use_default_colors()
+	curses.init_pair(1, -1, -1)
+	parsed_attr = __parse_ansi_escape_sequence_to_curses_attr('\x1b[31m')
+	stdscr.addnstr(0, 0, f'{parsed_attr}',stdscr.getmaxyx()[1], parsed_attr)
+	# get curses.A_BOLD
+	stdscr.addnstr(1, 0, f'{curses.A_BOLD}',stdscr.getmaxyx()[1], curses.A_BOLD)
+	stdscr.addnstr(2, 0, f'{parsed_attr | curses.A_BOLD}',stdscr.getmaxyx()[1], parsed_attr | curses.A_BOLD)
+	stdscr.addnstr(3, 0, f'{curses.A_DIM}',stdscr.getmaxyx()[1], parsed_attr | curses.A_DIM)
+	stdscr.addnstr(4, 0, f'{parsed_attr | curses.A_BOLD | curses.A_DIM}',stdscr.getmaxyx()[1], parsed_attr | curses.A_BOLD| curses.A_DIM)
+	stdscr.refresh()
+	stdscr.getch()
+	stdscr.clear()
+	#stdscr.idlok(True)
+	#stdscr.scrollok(True)
+	screen_size = stdscr.getmaxyx()
+
+	# Example line with ANSI color escape codes (including 8-bit and 24-bit colors)
+	color_pair_list = [-1,-1,1]
+	for i, line in enumerate(TEST_LINE):
+		_curses_add_string_to_window(window=stdscr, line=line, y = i,color_pair_list=color_pair_list,fill_char='-',centered=True,lead_str='|',trail_str='?|',box_ansi_color='\x1b[43;31;5m',keep_top_n_lines=2)
+	
+	#stdscr.addnstr(i+ 1, 0, 'test',10, 4)
+	stdscr.refresh()
+	stdscr.getch()
+	#stdscr.scroll(1)
+	stdscr.move(0,0)
+	stdscr.deleteln()
+	stdscr.refresh()
+	stdscr.getch()
+
+if __name__ == "__main__":
+	for i, color in enumerate(TEST_LINE):
+		print(f'{i}: {color}')
+	curses.wrapper(main)
+
+	#print(__curses_color_table)
+	#print(__curses_global_color_pairs)
+	for color in __curses_color_table:
+		print(f'{color}: {__curses_color_table[color]}, {curses.color_content(__curses_color_table[color])}')
+	for color_pair in __curses_global_color_pairs:
+		print(f'{color_pair}: {__curses_global_color_pairs[color_pair]}')
+	# for i in range(curses.COLORS):
+	# 	print(f'{i}: {curses.color_content(i)}')

multissh3-5.48/test/testCursesOld.py

@@ -0,0 +1,289 @@
+import curses
+import re
+import math
+
+# Global dictionary to store color pairs
+__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
+}
+
+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_global_color_pairs[(fg, bg)]
+
+def _add_line_with_ascii_colors(window, y, x, line, n, color_pair_list = [-1,-1,1]):
+	"""
+	Add a line to a curses window with ANSI escape sequences translated to curses color pairs.
+
+	Args:
+		window: curses window object
+		y: Line position in the window
+		x: Column position in the window
+		line: The string containing ANSI escape sequences for color
+		n: Maximum number of characters to write
+		host: The host object
+	
+	Returns:
+		None
+	"""
+	segments = re.split(r"(\x1b\[[\d;]*m)", line)  # Split line by ANSI escape codes
+	current_x = x
+	for segment in segments:
+		if 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])
+			pair = str(color_pair_list[2])
+			window.addstr(y, current_x, pair)
+			current_x += len(pair)
+		else:
+			# Add text with current color
+			if current_x < x + n:
+				#eprint(f"\ny: {y}, x: {current_x}, segment: {segment}, n: {n}, color_pair: {color_pair_list[2]}\n")
+				window.addnstr(y, current_x, segment, n - (current_x - x), curses.color_pair(color_pair_list[2]))
+				current_x += len(segment)
+
+
+TEST_LINE = (
+		"Standard \x1b[31mRed\x1b[0m, ",
+		"Bright \x1b[91mRed\x1b[0m, ",
+		"Standard \x1b[32mGreen\x1b[0m, ",
+		"Bright \x1b[92mGreen\x1b[0m, ",
+		"Standard \x1b[33mYellow\x1b[0m, ",
+		"Bright \x1b[93mYellow\x1b[0m, ",
+		"Standard \x1b[34mBlue\x1b[0m, ",
+		"Bright \x1b[94mBlue\x1b[0m, ",
+		"Standard \x1b[35mMagenta\x1b[0m, ",
+		"Bright \x1b[95mMagenta\x1b[0m, ",
+		"Standard \x1b[36mCyan\x1b[0m, ",
+		"Bright \x1b[96mCyan\x1b[0m, ",
+		"Standard \x1b[37mWhite\x1b[0m, ",
+		"Bright \x1b[97mWhite\x1b[0m, ",
+		"8-bit \x1b[38;5;196mRed\x1b[0m, ",
+		"8-bit \x1b[38;5;82mGreen\x1b[0m, ",
+		"8-bit \x1b[38;5;27mBlue\x1b[0m, ",
+		"8-bit \x1b[38;5;226mYellow\x1b[0m, ",
+		"8-bit \x1b[38;5;201mMagenta\x1b[0m, ",
+		"8-bit \x1b[38;5;51mCyan\x1b[0m, ",
+		"8-bit \x1b[38;5;15mWhite\x1b[0m, ",
+		"8-bit \x1b[38;5;0mBlack\x1b[0m, ",
+		"8-bit \x1b[38;5;4mBlue\x1b[0m, ",
+		"24-bit \x1b[38;2;128;128;128mGray\x1b[0m.",
+		"24-bit \x1b[38;2;255;165;0mOrange\x1b[0m.",
+		"24-bit \x1b[38;2;255;0;255mPink\x1b[0m.",
+		"24-bit \x1b[38;2;0;255;255mCyan\x1b[0m.",
+		"24-bit \x1b[38;2;255;255;255mWhite\x1b[0m.",
+		"24-bit \x1b[38;2;0;0;0mBlack\x1b[0m.",
+		"24-bit \x1b[38;2;128;128;128mGray\x1b[0m.",
+		"24-bit \x1b[38;2;255;0;0mRed\x1b[0m.",
+		"24-bit \x1b[38;2;0;255;0mGreen\x1b[0m.",
+		"24-bit \x1b[38;2;0;0;255mBlue\x1b[0m.",
+		"24-bit \x1b[38;2;255;255;0mYellow\x1b[0m.",
+		"24-bit \x1b[38;2;255;0;255mMagenta\x1b[0m.",
+		"24-bit \x1b[38;2;0;255;255mCyan colored dot.",
+		"Following string without reset color.",
+		"Following string with \x1b[31mRed color.",
+		"Following string with \x1b[31mRed color and \x1b[32mGreen color.",
+		"Reset color. \x1b[0mFollowing string with default color."
+	)
+# Example usage in a curses application
+def main(stdscr):
+	curses.start_color()
+	curses.use_default_colors()
+	curses.init_pair(1, -1, -1)
+	frontColor, backColor = __parse_ansi_escape_sequence_to_curses_color('\x1b[31;33m')
+	stdscr.addnstr(0, 0, f'frontColor,backColor:{frontColor},{backColor}',stdscr.getmaxyx()[1], 1)
+	stdscr.addnstr(1, 0, f'{curses.color_content(frontColor)}, {curses.color_content(backColor)}',stdscr.getmaxyx()[1], 1)
+	stdscr.refresh()
+	color_pair = __get_curses_color_pair(frontColor, backColor)
+	stdscr.addnstr(2, 0, f'color_pair {color_pair}',stdscr.getmaxyx()[1], color_pair)
+	stdscr.addnstr(3, 0, f'{curses.color_pair(color_pair)}',stdscr.getmaxyx()[1], color_pair)
+	stdscr.refresh()
+	stdscr.getch()
+	stdscr.clear()
+	#stdscr.idlok(True)
+	#stdscr.scrollok(True)
+	screen_size = stdscr.getmaxyx()
+
+	# Example line with ANSI color escape codes (including 8-bit and 24-bit colors)
+	color_pair_list = [-1,-1,1]
+	for i, line in enumerate(TEST_LINE):
+		_add_line_with_ascii_colors(stdscr, i, 0, line, screen_size[1], color_pair_list)
+
+	stdscr.refresh()
+	stdscr.getch()
+	#stdscr.scroll(1)
+	stdscr.move(0,0)
+	stdscr.deleteln()
+	stdscr.refresh()
+	stdscr.getch()
+
+
+if __name__ == "__main__":
+	for i, color in enumerate(TEST_LINE):
+		print(f'{i}: {color}')
+	curses.wrapper(main)
+
+	#print(__curses_color_table)
+	#print(__curses_global_color_pairs)
+	for color in __curses_color_table:
+		print(f'{color}: {__curses_color_table[color]}, {curses.color_content(__curses_color_table[color])}')
+	for color_pair in __curses_global_color_pairs:
+		print(f'{color_pair}: {__curses_global_color_pairs[color_pair]}')

multissh3-5.48/test/testPerfCompact.py

@@ -0,0 +1,31 @@
+import multiSSH3		
+import time
+
+print(multiSSH3.compact_hostnames(frozenset([f'PC{i}-{j:03d}' for i in range(8,11) for j in range(1, 3) ])))
+
+# bigZeroPaddedHosts = frozenset([f'PC{i:02d}-{j:02d}' for i in range(1, 200) for j in range(1, 3102)] + ['3-3PC','nebulamaster'])
+# print(f'len of bigZeroPaddedHosts: {len(bigZeroPaddedHosts)}')
+# startTime = time.perf_counter()
+# print(compact_hostnames(bigZeroPaddedHosts))
+# print(f'Time: {time.perf_counter() - startTime}')
+
+# hugeHosts = frozenset([f'PC{i}-{j:03d}-{k:05d}' for i in range(3, 40) for j in range(1, 50) for k in range(1, 100)] + ['3-3-3PC','nebulamaster'])
+# print(f'len of hugeHosts: {len(hugeHosts)}')
+# startTime = time.perf_counter()
+# print(compact_hostnames(hugeHosts))
+# print(f'Time: {time.perf_counter() - startTime}')
+
+# # %%
+# hugeHosts = frozenset([f'PC{i:01d}-{j:03d}-{k:03d}' for i in range(1, 100) for j in range(1, 50) for k in range(1, 100) if j != 8 if i != 35] + ['3-3-3PC','nebulamaster'])
+# startTime = time.perf_counter()
+# print(f'len of skipping hugerHosts: {len(hugeHosts)}')
+# print(compact_hostnames(hugeHosts))
+# print(f'Time: {time.perf_counter() - startTime}')
+
+
+ipRangeHosts = frozenset([f'10.{i}.{j}.{k}' for i in range(6, 13) for j in range(100, 255) for k in range(1, 255)] +[f'192.168.{j}.{k}' for k in range(100, 200) for j in range(1, 255) ]+ ['localhost'])
+print(f'len of ipRangeHosts: {len(ipRangeHosts)}')
+startTime = time.perf_counter()
+print(multiSSH3.compact_hostnames(ipRangeHosts))
+print(f'Time: {time.perf_counter() - startTime}')
+

multissh3-5.48/test/testPerfExpand.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+import multiSSH3
+import time
+
+ipRangeHosts = frozenset(['admin[1-10]@10.251.*.1-253','localhost'])
+print(f'len of ipRangeHosts: {len(ipRangeHosts)}')
+startTime = time.perf_counter()
+results = multiSSH3.expand_hostnames(ipRangeHosts)
+print(f'Time: {time.perf_counter() - startTime}')
+print(len(results))
+for i, result in enumerate(results.items()):
+	print(result)
+	if i > 10:
+		break