multiSSH3 5.6__py3-none-any.whl → 5.24__py3-none-any.whl

multiSSH3.py

@@ -1,5 +1,10 @@
 #!/usr/bin/env python3
-import curses
+__curses_available = False
+try:
+	import curses
+	__curses_available = True
+except ImportError:
+	pass
 import subprocess
 import threading
 import time,os
@@ -31,16 +36,159 @@ except AttributeError:
 		# If neither is available, use a dummy decorator
 		def cache_decorator(func):
 			return func
-version = '5.06'
+version = '5.24'
 VERSION = version
 
 CONFIG_FILE = '/etc/multiSSH3.config.json'	
 
-import sys
-
+# ------------ Pre Helper Functions ----------------
 def eprint(*args, **kwargs):
-    print(*args, file=sys.stderr, **kwargs)
+	try:
+		print(*args, file=sys.stderr, **kwargs)
+	except Exception as e:
+		print(f"Error: Cannot print to stderr: {e}")
+		print(*args, **kwargs)
+
+def signal_handler(sig, frame):
+	'''
+	Handle the Ctrl C signal
+
+	Args:
+		sig (int): The signal
+		frame (frame): The frame
+
+	Returns:
+		None
+	'''
+	global _emo
+	if not _emo:
+		eprint('Ctrl C caught, exiting...')
+		_emo = True
+	else:
+		eprint('Ctrl C caught again, exiting immediately!')
+		# wait for 0.1 seconds to allow the threads to exit
+		time.sleep(0.1)
+		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
+		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
+
+@cache_decorator
+def getIP(hostname: str,local=False):
+	'''
+	Get the IP address of the hostname
+
+	Args:
+		hostname (str): The hostname
+
+	Returns:
+		str: The IP address of the hostname
+	'''
+	global _etc_hosts
+	if '@' in hostname:
+		_, hostname = hostname.rsplit('@',1)
+	# First we check if the hostname is an IP address
+	try:
+		ipaddress.ip_address(hostname)
+		return hostname
+	except ValueError:
+		pass
+	# Then we check /etc/hosts
+	if not _etc_hosts and os.path.exists('/etc/hosts'):
+		with open('/etc/hosts','r') as f:
+			for line in f:
+				if line.startswith('#') or not line.strip():
+					continue
+				#ip, host = line.split()[:2]
+				chunks = line.split()
+				if len(chunks) < 2:
+					continue
+				ip = chunks[0]
+				for host in chunks[1:]:
+					_etc_hosts[host] = ip
+	if hostname in _etc_hosts:
+		return _etc_hosts[hostname]
+	if local:
+		return None
+	# Then we check the DNS
+	try:
+		return socket.gethostbyname(hostname)
+	except:
+		return None
+
+__host_i_lock = threading.Lock()
+__host_i_counter = -1
+def _get_i():
+	'''
+	Get the global counter for the host objects
 
+	Returns:
+	int: The global counter for the host objects
+	'''
+	global __host_i_counter
+	global __host_i_lock
+	with __host_i_lock:
+		__host_i_counter += 1
+		return __host_i_counter
+
+# ------------ Host Object ----------------
+class Host:
+	def __init__(self, name, command, files = None,ipmi = False,interface_ip_prefix = None,scp=False,extraargs=None,gatherMode=False,identity_file=None,bash=False,i = _get_i(),uuid=uuid.uuid4(),ip = None):
+		self.name = name # the name of the host (hostname or IP address)
+		self.command = command # the command to run on the host
+		self.returncode = None # the return code of the command
+		self.output = [] # the output of the command for curses
+		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.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
+		self.bash = bash # whether to use bash to run the command
+		self.interface_ip_prefix = interface_ip_prefix # the prefix of the ip address of the interface to be used to connect to the host
+		self.scp = scp # whether to use scp to copy files to the host
+		self.gatherMode = gatherMode # whether the host is in gather mode
+		self.extraargs = extraargs # extra arguments to be passed to ssh
+		self.resolvedName = None # the resolved IP address of the host
+		# also store a globally unique integer i from 0
+		self.i = i
+		self.uuid = uuid
+		self.identity_file = identity_file
+		self.ip = ip if ip else getIP(name)
+
+	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}"
+	def __str__(self):
+		return f"Host(name={self.name}, command={self.command}, returncode={self.returncode}, stdout={self.stdout}, stderr={self.stderr})"
+
+# ------------ Load Defaults ( Config ) File ----------------
 def load_config_file(config_file):
 	'''
 	Load the config file to global variables
@@ -57,7 +205,7 @@ def load_config_file(config_file):
 		with open(config_file,'r') as f:
 			config = json.load(f)
 	except:
-		eprint(f"Error: Cannot load config file {config_file}")
+		eprint(f"Error: Cannot load config file {config_file!r}")
 		return {}
 	return config
 
@@ -122,130 +270,79 @@ __build_in_default_config = {
 	'__DEBUG_MODE': False,
 }
 
-AUTHOR = __configs_from_file.get('AUTHOR', __build_in_default_config['AUTHOR'])
-AUTHOR_EMAIL = __configs_from_file.get('AUTHOR_EMAIL', __build_in_default_config['AUTHOR_EMAIL'])
-
-DEFAULT_HOSTS = __configs_from_file.get('DEFAULT_HOSTS', __build_in_default_config['DEFAULT_HOSTS'])
-DEFAULT_ENV_FILE = __configs_from_file.get('DEFAULT_ENV_FILE', __build_in_default_config['DEFAULT_ENV_FILE'])
-DEFAULT_USERNAME = __configs_from_file.get('DEFAULT_USERNAME', __build_in_default_config['DEFAULT_USERNAME'])
-DEFAULT_PASSWORD = __configs_from_file.get('DEFAULT_PASSWORD', __build_in_default_config['DEFAULT_PASSWORD'])
-DEFAULT_IDENTITY_FILE = __configs_from_file.get('DEFAULT_IDENTITY_FILE', __build_in_default_config['DEFAULT_IDENTITY_FILE'])
-DEDAULT_SSH_KEY_SEARCH_PATH = __configs_from_file.get('DEDAULT_SSH_KEY_SEARCH_PATH', __build_in_default_config['DEDAULT_SSH_KEY_SEARCH_PATH'])
-DEFAULT_USE_KEY = __configs_from_file.get('DEFAULT_USE_KEY', __build_in_default_config['DEFAULT_USE_KEY'])
-DEFAULT_EXTRA_ARGS = __configs_from_file.get('DEFAULT_EXTRA_ARGS', __build_in_default_config['DEFAULT_EXTRA_ARGS'])
-DEFAULT_ONE_ON_ONE = __configs_from_file.get('DEFAULT_ONE_ON_ONE', __build_in_default_config['DEFAULT_ONE_ON_ONE'])
-DEFAULT_SCP = __configs_from_file.get('DEFAULT_SCP', __build_in_default_config['DEFAULT_SCP'])
-DEFAULT_FILE_SYNC = __configs_from_file.get('DEFAULT_FILE_SYNC', __build_in_default_config['DEFAULT_FILE_SYNC'])
-DEFAULT_TIMEOUT = __configs_from_file.get('DEFAULT_TIMEOUT', __build_in_default_config['DEFAULT_TIMEOUT'])
-DEFAULT_CLI_TIMEOUT = __configs_from_file.get('DEFAULT_CLI_TIMEOUT', __build_in_default_config['DEFAULT_CLI_TIMEOUT'])
-DEFAULT_REPEAT = __configs_from_file.get('DEFAULT_REPEAT', __build_in_default_config['DEFAULT_REPEAT'])
-DEFAULT_INTERVAL = __configs_from_file.get('DEFAULT_INTERVAL', __build_in_default_config['DEFAULT_INTERVAL'])
-DEFAULT_IPMI = __configs_from_file.get('DEFAULT_IPMI', __build_in_default_config['DEFAULT_IPMI'])
-DEFAULT_IPMI_INTERFACE_IP_PREFIX = __configs_from_file.get('DEFAULT_IPMI_INTERFACE_IP_PREFIX', __build_in_default_config['DEFAULT_IPMI_INTERFACE_IP_PREFIX'])
-DEFAULT_INTERFACE_IP_PREFIX = __configs_from_file.get('DEFAULT_INTERFACE_IP_PREFIX', __build_in_default_config['DEFAULT_INTERFACE_IP_PREFIX'])
-DEFAULT_NO_WATCH = __configs_from_file.get('DEFAULT_NO_WATCH', __build_in_default_config['DEFAULT_NO_WATCH'])
-DEFAULT_CURSES_MINIMUM_CHAR_LEN = __configs_from_file.get('DEFAULT_CURSES_MINIMUM_CHAR_LEN', __build_in_default_config['DEFAULT_CURSES_MINIMUM_CHAR_LEN'])
-DEFAULT_CURSES_MINIMUM_LINE_LEN = __configs_from_file.get('DEFAULT_CURSES_MINIMUM_LINE_LEN', __build_in_default_config['DEFAULT_CURSES_MINIMUM_LINE_LEN'])
-DEFAULT_SINGLE_WINDOW = __configs_from_file.get('DEFAULT_SINGLE_WINDOW', __build_in_default_config['DEFAULT_SINGLE_WINDOW'])
-DEFAULT_ERROR_ONLY = __configs_from_file.get('DEFAULT_ERROR_ONLY', __build_in_default_config['DEFAULT_ERROR_ONLY'])
-DEFAULT_NO_OUTPUT = __configs_from_file.get('DEFAULT_NO_OUTPUT', __build_in_default_config['DEFAULT_NO_OUTPUT'])
-DEFAULT_NO_ENV = __configs_from_file.get('DEFAULT_NO_ENV', __build_in_default_config['DEFAULT_NO_ENV'])
-DEFAULT_MAX_CONNECTIONS = __configs_from_file.get('DEFAULT_MAX_CONNECTIONS', __build_in_default_config['DEFAULT_MAX_CONNECTIONS'])
-if not DEFAULT_MAX_CONNECTIONS:
-	DEFAULT_MAX_CONNECTIONS = 4 * os.cpu_count()
-DEFAULT_JSON_MODE = __configs_from_file.get('DEFAULT_JSON_MODE', __build_in_default_config['DEFAULT_JSON_MODE'])
-DEFAULT_PRINT_SUCCESS_HOSTS = __configs_from_file.get('DEFAULT_PRINT_SUCCESS_HOSTS', __build_in_default_config['DEFAULT_PRINT_SUCCESS_HOSTS'])
-DEFAULT_GREPPABLE_MODE = __configs_from_file.get('DEFAULT_GREPPABLE_MODE', __build_in_default_config['DEFAULT_GREPPABLE_MODE'])
-DEFAULT_SKIP_UNREACHABLE = __configs_from_file.get('DEFAULT_SKIP_UNREACHABLE', __build_in_default_config['DEFAULT_SKIP_UNREACHABLE'])
-DEFAULT_SKIP_HOSTS = __configs_from_file.get('DEFAULT_SKIP_HOSTS', __build_in_default_config['DEFAULT_SKIP_HOSTS'])
-
-SSH_STRICT_HOST_KEY_CHECKING = __configs_from_file.get('SSH_STRICT_HOST_KEY_CHECKING', __build_in_default_config['SSH_STRICT_HOST_KEY_CHECKING'])
-
-ERROR_MESSAGES_TO_IGNORE = __configs_from_file.get('ERROR_MESSAGES_TO_IGNORE', __build_in_default_config['ERROR_MESSAGES_TO_IGNORE'])
-
-_DEFAULT_CALLED = __configs_from_file.get('_DEFAULT_CALLED', __build_in_default_config['_DEFAULT_CALLED'])
-_DEFAULT_RETURN_UNFINISHED = __configs_from_file.get('_DEFAULT_RETURN_UNFINISHED', __build_in_default_config['_DEFAULT_RETURN_UNFINISHED'])
-_DEFAULT_UPDATE_UNREACHABLE_HOSTS = __configs_from_file.get('_DEFAULT_UPDATE_UNREACHABLE_HOSTS', __build_in_default_config['_DEFAULT_UPDATE_UNREACHABLE_HOSTS'])
-_DEFAULT_NO_START = __configs_from_file.get('_DEFAULT_NO_START', __build_in_default_config['_DEFAULT_NO_START'])
-
-# form the regex from the list
-__ERROR_MESSAGES_TO_IGNORE_REGEX = __configs_from_file.get('__ERROR_MESSAGES_TO_IGNORE_REGEX', __build_in_default_config['__ERROR_MESSAGES_TO_IGNORE_REGEX'])
-if __ERROR_MESSAGES_TO_IGNORE_REGEX:
-	eprint('Using __ERROR_MESSAGES_TO_IGNORE_REGEX from config file, ignoring ERROR_MESSAGES_TO_IGNORE')
-	__ERROR_MESSAGES_TO_IGNORE_REGEX = re.compile(__configs_from_file['__ERROR_MESSAGES_TO_IGNORE_REGEX'])
-else:
-	__ERROR_MESSAGES_TO_IGNORE_REGEX =  re.compile('|'.join(ERROR_MESSAGES_TO_IGNORE))
-
-__DEBUG_MODE = __configs_from_file.get('__DEBUG_MODE', __build_in_default_config['__DEBUG_MODE'])
-
-
-
-__global_suppress_printout = False
-
-__mainReturnCode = 0
-__failedHosts = set()
-__host_i_lock = threading.Lock()
-__host_i_counter = -1
-def get_i():
-	'''
-	Get the global counter for the host objects
-
-	Returns:
-	int: The global counter for the host objects
-	'''
-	global __host_i_counter
-	global __host_i_lock
-	with __host_i_lock:
-		__host_i_counter += 1
-		return __host_i_counter
-	
-class Host:
-	def __init__(self, name, command, files = None,ipmi = False,interface_ip_prefix = None,scp=False,extraargs=None,gatherMode=False,identity_file=None):
-		self.name = name # the name of the host (hostname or IP address)
-		self.command = command # the command to run on the host
-		self.returncode = None # the return code of the command
-		self.output = [] # the output of the command for curses
-		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.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
-		self.interface_ip_prefix = interface_ip_prefix # the prefix of the ip address of the interface to be used to connect to the host
-		self.scp = scp # whether to use scp to copy files to the host
-		self.gatherMode = gatherMode # whether the host is in gather mode
-		self.extraargs = extraargs # extra arguments to be passed to ssh
-		self.resolvedName = None # the resolved IP address of the host
-		# also store a globally unique integer i from 0
-		self.i = get_i()
-		self.uuid = uuid.uuid4()
-		self.identity_file = identity_file
-
-	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}"
-	def __str__(self):
-		return f"Host(name={self.name}, command={self.command}, returncode={self.returncode}, stdout={self.stdout}, stderr={self.stderr})"
-
-__wildCharacters = ['*','?','x']
-
-_no_env = DEFAULT_NO_ENV
-
-_env_file = DEFAULT_ENV_FILE
-
-__globalUnavailableHosts = set()
-
-__ipmiiInterfaceIPPrefix = DEFAULT_IPMI_INTERFACE_IP_PREFIX
-
-__keyPressesIn = [[]]
-
-_emo = False
-
-_etc_hosts = __configs_from_file.get('_etc_hosts', __build_in_default_config['_etc_hosts'])
-
+# Load Config Based Default Global variables
+if True:
+	AUTHOR = __configs_from_file.get('AUTHOR', __build_in_default_config['AUTHOR'])
+	AUTHOR_EMAIL = __configs_from_file.get('AUTHOR_EMAIL', __build_in_default_config['AUTHOR_EMAIL'])
+
+	DEFAULT_HOSTS = __configs_from_file.get('DEFAULT_HOSTS', __build_in_default_config['DEFAULT_HOSTS'])
+	DEFAULT_ENV_FILE = __configs_from_file.get('DEFAULT_ENV_FILE', __build_in_default_config['DEFAULT_ENV_FILE'])
+	DEFAULT_USERNAME = __configs_from_file.get('DEFAULT_USERNAME', __build_in_default_config['DEFAULT_USERNAME'])
+	DEFAULT_PASSWORD = __configs_from_file.get('DEFAULT_PASSWORD', __build_in_default_config['DEFAULT_PASSWORD'])
+	DEFAULT_IDENTITY_FILE = __configs_from_file.get('DEFAULT_IDENTITY_FILE', __build_in_default_config['DEFAULT_IDENTITY_FILE'])
+	DEDAULT_SSH_KEY_SEARCH_PATH = __configs_from_file.get('DEDAULT_SSH_KEY_SEARCH_PATH', __build_in_default_config['DEDAULT_SSH_KEY_SEARCH_PATH'])
+	DEFAULT_USE_KEY = __configs_from_file.get('DEFAULT_USE_KEY', __build_in_default_config['DEFAULT_USE_KEY'])
+	DEFAULT_EXTRA_ARGS = __configs_from_file.get('DEFAULT_EXTRA_ARGS', __build_in_default_config['DEFAULT_EXTRA_ARGS'])
+	DEFAULT_ONE_ON_ONE = __configs_from_file.get('DEFAULT_ONE_ON_ONE', __build_in_default_config['DEFAULT_ONE_ON_ONE'])
+	DEFAULT_SCP = __configs_from_file.get('DEFAULT_SCP', __build_in_default_config['DEFAULT_SCP'])
+	DEFAULT_FILE_SYNC = __configs_from_file.get('DEFAULT_FILE_SYNC', __build_in_default_config['DEFAULT_FILE_SYNC'])
+	DEFAULT_TIMEOUT = __configs_from_file.get('DEFAULT_TIMEOUT', __build_in_default_config['DEFAULT_TIMEOUT'])
+	DEFAULT_CLI_TIMEOUT = __configs_from_file.get('DEFAULT_CLI_TIMEOUT', __build_in_default_config['DEFAULT_CLI_TIMEOUT'])
+	DEFAULT_REPEAT = __configs_from_file.get('DEFAULT_REPEAT', __build_in_default_config['DEFAULT_REPEAT'])
+	DEFAULT_INTERVAL = __configs_from_file.get('DEFAULT_INTERVAL', __build_in_default_config['DEFAULT_INTERVAL'])
+	DEFAULT_IPMI = __configs_from_file.get('DEFAULT_IPMI', __build_in_default_config['DEFAULT_IPMI'])
+	DEFAULT_IPMI_INTERFACE_IP_PREFIX = __configs_from_file.get('DEFAULT_IPMI_INTERFACE_IP_PREFIX', __build_in_default_config['DEFAULT_IPMI_INTERFACE_IP_PREFIX'])
+	DEFAULT_INTERFACE_IP_PREFIX = __configs_from_file.get('DEFAULT_INTERFACE_IP_PREFIX', __build_in_default_config['DEFAULT_INTERFACE_IP_PREFIX'])
+	DEFAULT_NO_WATCH = __configs_from_file.get('DEFAULT_NO_WATCH', __build_in_default_config['DEFAULT_NO_WATCH'])
+	DEFAULT_CURSES_MINIMUM_CHAR_LEN = __configs_from_file.get('DEFAULT_CURSES_MINIMUM_CHAR_LEN', __build_in_default_config['DEFAULT_CURSES_MINIMUM_CHAR_LEN'])
+	DEFAULT_CURSES_MINIMUM_LINE_LEN = __configs_from_file.get('DEFAULT_CURSES_MINIMUM_LINE_LEN', __build_in_default_config['DEFAULT_CURSES_MINIMUM_LINE_LEN'])
+	DEFAULT_SINGLE_WINDOW = __configs_from_file.get('DEFAULT_SINGLE_WINDOW', __build_in_default_config['DEFAULT_SINGLE_WINDOW'])
+	DEFAULT_ERROR_ONLY = __configs_from_file.get('DEFAULT_ERROR_ONLY', __build_in_default_config['DEFAULT_ERROR_ONLY'])
+	DEFAULT_NO_OUTPUT = __configs_from_file.get('DEFAULT_NO_OUTPUT', __build_in_default_config['DEFAULT_NO_OUTPUT'])
+	DEFAULT_NO_ENV = __configs_from_file.get('DEFAULT_NO_ENV', __build_in_default_config['DEFAULT_NO_ENV'])
+	DEFAULT_MAX_CONNECTIONS = __configs_from_file.get('DEFAULT_MAX_CONNECTIONS', __build_in_default_config['DEFAULT_MAX_CONNECTIONS'])
+	if not DEFAULT_MAX_CONNECTIONS:
+		DEFAULT_MAX_CONNECTIONS = 4 * os.cpu_count()
+	DEFAULT_JSON_MODE = __configs_from_file.get('DEFAULT_JSON_MODE', __build_in_default_config['DEFAULT_JSON_MODE'])
+	DEFAULT_PRINT_SUCCESS_HOSTS = __configs_from_file.get('DEFAULT_PRINT_SUCCESS_HOSTS', __build_in_default_config['DEFAULT_PRINT_SUCCESS_HOSTS'])
+	DEFAULT_GREPPABLE_MODE = __configs_from_file.get('DEFAULT_GREPPABLE_MODE', __build_in_default_config['DEFAULT_GREPPABLE_MODE'])
+	DEFAULT_SKIP_UNREACHABLE = __configs_from_file.get('DEFAULT_SKIP_UNREACHABLE', __build_in_default_config['DEFAULT_SKIP_UNREACHABLE'])
+	DEFAULT_SKIP_HOSTS = __configs_from_file.get('DEFAULT_SKIP_HOSTS', __build_in_default_config['DEFAULT_SKIP_HOSTS'])
+
+	SSH_STRICT_HOST_KEY_CHECKING = __configs_from_file.get('SSH_STRICT_HOST_KEY_CHECKING', __build_in_default_config['SSH_STRICT_HOST_KEY_CHECKING'])
+
+	ERROR_MESSAGES_TO_IGNORE = __configs_from_file.get('ERROR_MESSAGES_TO_IGNORE', __build_in_default_config['ERROR_MESSAGES_TO_IGNORE'])
+
+	_DEFAULT_CALLED = __configs_from_file.get('_DEFAULT_CALLED', __build_in_default_config['_DEFAULT_CALLED'])
+	_DEFAULT_RETURN_UNFINISHED = __configs_from_file.get('_DEFAULT_RETURN_UNFINISHED', __build_in_default_config['_DEFAULT_RETURN_UNFINISHED'])
+	_DEFAULT_UPDATE_UNREACHABLE_HOSTS = __configs_from_file.get('_DEFAULT_UPDATE_UNREACHABLE_HOSTS', __build_in_default_config['_DEFAULT_UPDATE_UNREACHABLE_HOSTS'])
+	_DEFAULT_NO_START = __configs_from_file.get('_DEFAULT_NO_START', __build_in_default_config['_DEFAULT_NO_START'])
+
+	# form the regex from the list
+	__ERROR_MESSAGES_TO_IGNORE_REGEX = __configs_from_file.get('__ERROR_MESSAGES_TO_IGNORE_REGEX', __build_in_default_config['__ERROR_MESSAGES_TO_IGNORE_REGEX'])
+	if __ERROR_MESSAGES_TO_IGNORE_REGEX:
+		eprint('Using __ERROR_MESSAGES_TO_IGNORE_REGEX from config file, ignoring ERROR_MESSAGES_TO_IGNORE')
+		__ERROR_MESSAGES_TO_IGNORE_REGEX = re.compile(__configs_from_file['__ERROR_MESSAGES_TO_IGNORE_REGEX'])
+	else:
+		__ERROR_MESSAGES_TO_IGNORE_REGEX =  re.compile('|'.join(ERROR_MESSAGES_TO_IGNORE))
+
+	__DEBUG_MODE = __configs_from_file.get('__DEBUG_MODE', __build_in_default_config['__DEBUG_MODE'])
+
+# Load mssh Functional Global Variables
+if True:
+	__global_suppress_printout = False
+	__mainReturnCode = 0
+	__failedHosts = set()
+	__wildCharacters = ['*','?','x']
+	_no_env = DEFAULT_NO_ENV
+	_env_file = DEFAULT_ENV_FILE
+	__globalUnavailableHosts = set()
+	__ipmiiInterfaceIPPrefix = DEFAULT_IPMI_INTERFACE_IP_PREFIX
+	__keyPressesIn = [[]]
+	_emo = False
+	_etc_hosts = __configs_from_file.get('_etc_hosts', __build_in_default_config['_etc_hosts'])
 
+# ------------ Exportable Help Functions ----------------
 # check if command sshpass is available
 _binPaths = {}
 def check_path(program_name):
@@ -265,130 +362,531 @@ def check_path(program_name):
 
 [check_path(program) for program in ['sshpass', 'ssh', 'scp', 'ipmitool','rsync','bash','ssh-copy-id']]
 
+def find_ssh_key_file(searchPath = DEDAULT_SSH_KEY_SEARCH_PATH):
+	'''
+	Find the ssh public key file
+
+	Args:
+		searchPath (str, optional): The path to search. Defaults to DEDAULT_SSH_KEY_SEARCH_PATH.
 
+	Returns:
+		str: The path to the ssh key file
+	'''
+	if searchPath:
+		sshKeyPath = searchPath
+	else:
+		sshKeyPath ='~/.ssh'
+	possibleSshKeyFiles = ['id_ed25519','id_ed25519_sk','id_ecdsa','id_ecdsa_sk','id_rsa','id_dsa']
+	for sshKeyFile in possibleSshKeyFiles:
+		if os.path.exists(os.path.expanduser(os.path.join(sshKeyPath,sshKeyFile))):
+			return os.path.join(sshKeyPath,sshKeyFile)
+	return None
 
 @cache_decorator
-def expandIPv4Address(hosts):
+def readEnvFromFile(environemnt_file = ''):
 	'''
-	Expand the IP address range in the hosts list
+	Read the environment variables from env_file
+	Returns:
+		dict: A dictionary of environment variables
+	'''
+	global env
+	try:
+		if env:
+			return env
+	except:
+		env = {}
+	global _env_file
+	if environemnt_file:
+		envf = environemnt_file
+	else:
+		envf = _env_file if _env_file else DEFAULT_ENV_FILE
+	if os.path.exists(envf):
+		with open(envf,'r') as f:
+			for line in f:
+				if line.startswith('#') or not line.strip():
+					continue
+				key, value = line.replace('export ', '', 1).strip().split('=', 1)
+				key = key.strip().strip('"').strip("'")
+				value = value.strip().strip('"').strip("'")
+				# avoid infinite recursion
+				if key != value:
+					env[key] = value.strip('"').strip("'")
+	return env
+
+def replace_magic_strings(string,keys,value,case_sensitive=False):
+	'''
+	Replace the magic strings in the host object
 
 	Args:
-		hosts (list): A list of IP addresses or IP address ranges
+		string (str): The string to replace the magic strings
+		keys (list): Search for keys to replace
+		value (str): The value to replace the key
+		case_sensitive (bool, optional): Whether to search for the keys in a case sensitive way. Defaults to False.
 
 	Returns:
-		list: A list of expanded IP addresses
+		str: The string with the magic strings replaced
 	'''
-	expandedHosts = []
-	expandedHost = []
-	for host in hosts:
-		host = host.replace('[','').replace(']','')
-		octets = host.split('.')
-		expandedOctets = []
-		for octet in octets:
-			if '-' in octet:
-				# Handle wildcards
-				octetRange = octet.split('-')
-				for i in range(len(octetRange)):
-					if not octetRange[i] or octetRange[i] in __wildCharacters:
-						if i == 0:
-							octetRange[i] = '0'
-						elif i == 1:
-							octetRange[i] = '255'
-				
-				expandedOctets.append([str(i) for i in range(int(octetRange[0]),int(octetRange[1])+1)])
-			elif octet in __wildCharacters:
-				expandedOctets.append([str(i) for i in range(0,256)])
+	# verify magic strings have # at the beginning and end
+	newKeys = []
+	for key in keys:
+		if key.startswith('#') and key.endswith('#'):
+			newKeys.append(key)
+		else:
+			newKeys.append('#'+key.strip('#')+'#')
+	# replace the magic strings
+	for key in newKeys:
+		if case_sensitive:
+			string = string.replace(key,value)
+		else:
+			string = re.sub(re.escape(key),value,string,flags=re.IGNORECASE)
+	return string
+
+def pretty_format_table(data):
+	if not data:
+		return ''
+	if type(data) == str:
+		data = data.strip('\n').split('\n')
+		data = [line.split('\t') for line in data]
+	elif isinstance(data, dict):
+		# flatten the 2D dict to a list of lists
+		if isinstance(next(iter(data.values())), dict):
+			tempData = [['key'] + list(next(iter(data.values())).keys())]
+			tempData.extend( [[key] + list(value.values()) for key, value in data.items()])
+			data = tempData
+		else:
+			# it is a dict of lists
+			data = [[key] + list(value) for key, value in data.items()]
+	elif type(data) != list:
+		data = list(data)
+	# TODO : add support for list of dictionaries
+	# format the list into 2d list of list of strings
+	if isinstance(data[0], dict):
+		tempData = [data[0].keys()]
+		tempData.extend([list(item.values()) for item in data])
+		data = tempData
+	data = [[str(item) for item in row] for row in data]
+	num_cols = len(data[0])
+	col_widths = [0] * num_cols
+	# Calculate the maximum width of each column
+	for c in range(num_cols):
+		col_widths[c] = max(len(row[c]) for row in data)
+	# Build the row format string
+	row_format = ' | '.join('{{:<{}}}'.format(width) for width in col_widths)
+	# Print the header
+	header = data[0]
+	outTable = []
+	outTable.append(row_format.format(*header))
+	outTable.append('-+-'.join('-' * width for width in col_widths))
+	for row in data[1:]:
+		# if the row is empty, print an divider
+		if not any(row):
+			outTable.append('-+-'.join('-' * width for width in col_widths))
+		else:
+			outTable.append(row_format.format(*row))
+	return '\n'.join(outTable) + '\n'
+
+# ------------ Compacting Hostnames ----------------
+def __tokenize_hostname(hostname):
+	"""
+	Tokenize the hostname into a list of tokens.
+	Tokens will be separated by symbols or numbers.
+
+	Args:
+		hostname (str): The hostname to tokenize.
+
+	Returns:
+		list: A list of tokens.
+
+	Example:
+		>>> tokenize_hostname('www.example.com')
+		('www', '.', 'example', '.', 'com')
+		>>> tokenize_hostname('localhost')
+		('localhost',)
+		>>> tokenize_hostname('Sub-S1')
+		('Sub', '-', 'S', '1')
+		>>> tokenize_hostname('Sub-S10')
+		('Sub', '-', 'S', '10')
+		>>> tokenize_hostname('Process-Client10-1')
+		('Process', '-', 'Client', '10', '-', '1')
+		>>> tokenize_hostname('Process-C5-15')
+		('Process', '-', 'C', '5', '-', '15')
+		>>> tokenize_hostname('192.168.1.1')
+		('192', '.', '168', '.', '1', '.', '1')
+	"""
+	# Regular expression to match sequences of letters, digits, or symbols
+	tokens = re.findall(r'[A-Za-z]+|\d+|[^A-Za-z0-9]', hostname)
+	return tuple(tokens)
+
+def __hashTokens(tokens):
+	"""
+	Translate a list of tokens in string to a list of integers with positional information.
+
+	Args:
+		tokens (tuple): A tuple of tokens.
+
+	Returns:
+		list: A list of integers.
+
+	Example:
+		>>> tuple(hashTokens(('1')))
+		(1,)
+		>>> tuple(hashTokens(('1', '2')))
+		(1, 2)
+		>>> tuple(hashTokens(('1', '.', '2')))
+		(1, -5047856122680242044, 2)
+		>>> tuple(hashTokens(('Process', '-', 'C', '5', '-', '15')))
+		(117396829274297939, 7549860403020794775, 8629208860073383633, 5, 7549860403020794775, 15)
+		>>> tuple(hashTokens(('192', '.', '168', '.', '1', '.', '1')))
+		(192, -5047856122680242044, 168, -5047856122680242044, 1, -5047856122680242044, 1)
+	"""
+	return tuple(int(token) if token.isdigit() else hash(token) for token in tokens)
+
+def __findDiffIndex(token1, token2):
+	"""
+	Find the index of the first difference between two lists of tokens.
+	If there is more than one difference, return -1.
+
+	Args:
+		token1 (tuple): A list of tokens.
+		token2 (tuple): A list of tokens.
+
+	Returns:
+		int: The index of the first difference between the two lists of tokens.
+
+	Example:
+		>>> findDiffIndex(('1',), ('1',))
+		-1
+		>>> findDiffIndex(('1','2'), ('1', '1'))
+		1
+		>>> findDiffIndex(('1','1'), ('1', '1', '1'))
+		Traceback (most recent call last):
+		...
+		ValueError: The two lists must have the same length.
+		>>> findDiffIndex(('192', '.', '168', '.', '2', '.', '1'), ('192', '.', '168', '.', '1', '.', '1'))
+		4
+		>>> findDiffIndex(('192', '.', '168', '.', '2', '.', '1'), ('192', '.', '168', '.', '1', '.', '2'))
+		-1
+		>>> findDiffIndex(('Process', '-', 'C', '5', '-', '15'), ('Process', '-', 'C', '5', '-', '15'))
+		-1
+		>>> findDiffIndex(('Process', '-', 'C', '5', '-', '15'), ('Process', '-', 'C', '5', '-', '16'))
+		5
+		>>> findDiffIndex(tokenize_hostname('nebulahost3'), tokenize_hostname('nebulaleaf3'))
+		-1
+		>>> findDiffIndex(tokenize_hostname('nebulaleaf3'), tokenize_hostname('nebulaleaf4'))
+		1
+	"""
+	if len(token1) != len(token2):
+		raise ValueError('The two lists must have the same length.')
+	rtn = -1
+	for i, (subToken1, subToken2) in enumerate(zip(token1, token2)):
+		if subToken1 != subToken2:
+			if rtn == -1 and subToken1.isdigit() and subToken2.isdigit():
+				rtn = i
 			else:
-				expandedOctets.append([octet])
-		# handle the first and last subnet addresses
-		if '0' in expandedOctets[-1]:
-			expandedOctets[-1].remove('0')
-		if '255' in expandedOctets[-1]:
-			expandedOctets[-1].remove('255')
-		#print(expandedOctets)
-		# Generate the expanded hosts
-		for ip in list(product(expandedOctets[0],expandedOctets[1],expandedOctets[2],expandedOctets[3])):
-			expandedHost.append('.'.join(ip))
-	expandedHosts.extend(expandedHost)
-	return expandedHosts
+				return -1
+	return rtn
+
+def __generateSumDic(Hostnames):
+	"""
+	Generate a dictionary of sums of tokens for a list of hostnames.
+
+	Args:
+		Hostnames (list): A list of hostnames.
+
+	Example:
+		>>> generateSumDic(['localhost'])
+		{6564370170492138900: {('localhost',): {}}}
+		>>> generateSumDic(['1', '2'])
+		{1: {('1',): {}}, 2: {('2',): {}}}
+		>>> generateSumDic(['1.1','1.2'])
+		{3435203479547611399: {('1', '.', '1'): {}}, 3435203479547611400: {('1', '.', '2'): {}}}
+		>>> generateSumDic(['1.2','2.1'])
+		{3435203479547611400: {('1', '.', '2'): {}, ('2', '.', '1'): {}}}
+	"""
+	sumDic = {}
+	for hostname in reversed(sorted(Hostnames)):
+		tokens = __tokenize_hostname(hostname)
+		sumHash = sum(__hashTokens(tokens))
+		sumDic.setdefault(sumHash, {})[tokens] = {}
+	return sumDic
+
+def __filterSumDic(sumDic):
+	"""
+	Filter the sumDic to do one order of grouping.
 
+	Args:
+		sumDic (dict): A dictionary of sums of tokens.
+
+	Returns:
+		dict: A filtered dictionary of sums of tokens.
+
+	Example:
+		>>> filterSumDic(generateSumDic(['server15', 'server16', 'server17']))
+		{-6728831096159691241: {('server', '17'): {(1, 0): [15, 17]}}}
+		>>> filterSumDic(generateSumDic(['server15', 'server16', 'server17', 'server18']))
+		{-6728831096159691240: {('server', '18'): {(1, 0): [15, 18]}}}
+		>>> filterSumDic(generateSumDic(['server-1', 'server-2', 'server-3']))
+		{1441623239094376437: {('server', '-', '3'): {(2, 0): [1, 3]}}}
+		>>> filterSumDic(generateSumDic(['server-1-2', 'server-1-1', 'server-2-1', 'server-2-2']))
+		{9612077574348444129: {('server', '-', '1', '-', '2'): {(4, 0): [1, 2]}}, 9612077574348444130: {('server', '-', '2', '-', '2'): {(4, 0): [1, 2]}}}
+		>>> filterSumDic(generateSumDic(['server-1-2', 'server-1-1', 'server-2-2']))
+		{9612077574348444129: {('server', '-', '1', '-', '2'): {(4, 0): [1, 2]}}, 9612077574348444130: {('server', '-', '2', '-', '2'): {}}}
+		>>> filterSumDic(generateSumDic(['test1-a', 'test2-a']))
+		{12310874833182455839: {('test', '2', '-', 'a'): {(1, 0): [1, 2]}}}
+		>>> filterSumDic(generateSumDic(['sub-s1', 'sub-s2']))
+		{15455586825715425366: {('sub', '-', 's', '2'): {(3, 0): [1, 2]}}}
+		>>> filterSumDic(generateSumDic(['s9', 's10', 's11']))
+		{1169697225593811728: {('s', '11'): {(1, 0): [9, 11]}}}
+		>>> filterSumDic(generateSumDic(['s99', 's98', 's100','s101']))
+		{1169697225593811818: {('s', '101'): {(1, 0): [98, 101]}}}
+		>>> filterSumDic(generateSumDic(['s08', 's09', 's10', 's11']))
+		{1169697225593811728: {('s', '11'): {(1, 2): [8, 11]}}}
+		>>> filterSumDic(generateSumDic(['s099', 's098', 's100','s101']))
+		{1169697225593811818: {('s', '101'): {(1, 3): [98, 101]}}}
+		>>> filterSumDic(generateSumDic(['server1', 'server2', 'server3','server04']))
+		{-6728831096159691255: {('server', '3'): {(1, 0): [1, 3]}}, -6728831096159691254: {('server', '04'): {}}}
+		>>> filterSumDic(generateSumDic(['server9', 'server09', 'server10','server10']))
+		{-6728831096159691249: {('server', '09'): {}}, -6728831096159691248: {('server', '10'): {(1, 0): [9, 10]}}}
+		>>> filterSumDic(generateSumDic(['server09', 'server9', 'server10']))
+		{-6728831096159691249: {('server', '9'): {}}, -6728831096159691248: {('server', '10'): {(1, 2): [9, 10]}}}
+	"""
+	lastSumHash = None
+	newSumDic = {}    
+	for key, value in sumDic.items():
+		newSumDic[key] = value.copy()
+	sumDic = newSumDic
+	newSumDic = {}
+	for sumHash in sorted(sumDic):
+		if lastSumHash is None:
+			lastSumHash = sumHash
+			newSumDic[sumHash] = sumDic[sumHash].copy()
+			continue
+		if sumHash - lastSumHash == 1:
+			# this means the distence between these two group of hostnames is 1, thus we try to group them together
+			for hostnameTokens in sumDic[sumHash]:
+				added = False
+				if lastSumHash in newSumDic and sumDic[lastSumHash]:
+					for lastHostnameTokens in sumDic[lastSumHash].copy():
+						# if the two hostnames are able to group, we group them together
+						# the two hostnames are able to group if:
+						# 1. the two hostnames have the same amount of tokens
+						# 2. the last hostname is not already been grouped
+						# 3. the two hostnames have the same tokens except for one token
+						# 4. the two hostnames have the same token groups
+						if len(hostnameTokens) == len(lastHostnameTokens) and \
+							lastSumHash in newSumDic and lastHostnameTokens in newSumDic[lastSumHash]:
+							#(diffIndex:=findDiffIndex(hostnameTokens, lastHostnameTokens)) != -1 and \
+							diffIndex=__findDiffIndex(hostnameTokens, lastHostnameTokens)
+							if diffIndex != -1 and \
+								sumDic[sumHash][hostnameTokens] == sumDic[lastSumHash][lastHostnameTokens]:
+								# the sumDic[sumHash][hostnameTokens] will ba a dic of 2 element value lists with 2 element key representing:
+								# (token position that got grouped, the amount of zero padding (length) ):
+								#   [ the start int token, the end int token]
+								# if we entered here, this means we are able to group the two hostnames together
+
+								if not diffIndex:
+									# should never happen, but just in case, we skip grouping
+									continue
+								tokenToGroup = hostnameTokens[diffIndex]
+								try:
+									tokenLength = len(tokenToGroup)
+									tokenToGroup = int(tokenToGroup)
+								except ValueError:
+									# if the token is not an int, we skip grouping
+									continue
+								# group(09 , 10) -> (x, 2): [9, 10]
+								# group(9 , 10) -> (x, 0): [9, 10]
+								# group(9 , 010) -> not able to group
+								# group(009 , 10) -> not able to group
+								# group(08, 09) -> (x, 2): [8, 9]
+								# group(08, 9) -> not able to group
+								# group(8, 09) -> not able to group
+								# group(0099, 0100) -> (x, 4): [99, 100]
+								# group(0099, 100) -> not able to groups
+								# group(099, 100) -> (x, 3): [99, 100]
+								# group(99, 100) -> (x, 0): [99, 100]
+								lastTokenToGroup = lastHostnameTokens[diffIndex]
+								try:
+									minimumTokenLength = 0
+									lastTokenLength = len(lastTokenToGroup) 
+									if lastTokenLength > tokenLength:
+										raise ValueError('The last token is longer than the current token.')
+									elif lastTokenLength < tokenLength:
+										if tokenLength - lastTokenLength != 1:
+											raise ValueError('The last token is not one less than the current token.')
+										# if the last token is not made out of all 9s, we cannot group
+										if any(c != '9' for c in lastTokenToGroup):
+											raise ValueError('The last token is not made out of all 9s.')
+									elif lastTokenToGroup[0] == '0' and lastTokenLength > 1:
+										# we have encoutered a padded last token, will set this as the minimum token length
+										minimumTokenLength = lastTokenLength
+									lastTokenToGroup = int(lastTokenToGroup)
+								except ValueError:
+									# if the token is not an int, we skip grouping
+									continue
+								assert lastTokenToGroup + 1 == tokenToGroup, 'Error! The two tokens are not one apart.'
+								# we take the last hostname tokens grouped dic out from the newSumDic
+								hostnameGroupDic = newSumDic[lastSumHash][lastHostnameTokens].copy()
+								if (diffIndex, minimumTokenLength) in hostnameGroupDic and hostnameGroupDic[(diffIndex, minimumTokenLength)][1] + 1 == tokenToGroup:
+									# if the token is already grouped, we just update the end token
+									hostnameGroupDic[(diffIndex, minimumTokenLength)][1] = tokenToGroup
+								elif (diffIndex, tokenLength) in hostnameGroupDic and hostnameGroupDic[(diffIndex, tokenLength)][1] + 1 == tokenToGroup:
+									# alternatively, there is already an exact length padded token grouped
+									hostnameGroupDic[(diffIndex, tokenLength)][1] = tokenToGroup
+								elif sumDic[lastSumHash][lastHostnameTokens] == newSumDic[lastSumHash][lastHostnameTokens]:
+									# only when there are no new groups added to this token group this iter, we can add the new group
+									hostnameGroupDic[(diffIndex, minimumTokenLength)] = [lastTokenToGroup, tokenToGroup]
+								else:
+									# skip grouping if there are new groups added to this token group this iter
+									continue
+								# move the grouped dic under the new hostname / sum hash
+								del newSumDic[lastSumHash][lastHostnameTokens]
+								del sumDic[lastSumHash][lastHostnameTokens]
+								if not newSumDic[lastSumHash]:
+									del newSumDic[lastSumHash]
+								newSumDic.setdefault(sumHash, {})[hostnameTokens] = hostnameGroupDic
+								# we add the new group to the newSumDic
+								added = True
+								break
+				if not added:
+					# if the two hostnames are not able to group, we just add the last group to the newSumDic
+					newSumDic.setdefault(sumHash, {})[hostnameTokens] = sumDic[sumHash][hostnameTokens].copy()
+		else:
+			# this means the distence between these two group of hostnames is not 1, thus we just add the last group to the newSumDic
+			newSumDic[sumHash] = sumDic[sumHash].copy()
+		lastSumHash = sumHash
+	return newSumDic
+
+@cache_decorator
+def compact_hostnames(Hostnames):
+	"""
+	Compact a list of hostnames.
+	Compact numeric numbers into ranges.
+
+	Args:
+		Hostnames (list): A list of hostnames.
+
+	Returns:
+		list: A list of comapcted hostname list.
+
+	Example:
+		>>> compact_hostnames(['server15', 'server16', 'server17'])
+		['server[15-17]']
+		>>> compact_hostnames(['server-1', 'server-2', 'server-3'])
+		['server-[1-3]']
+		>>> compact_hostnames(['server-1-2', 'server-1-1', 'server-2-1', 'server-2-2'])
+		['server-[1-2]-[1-2]']
+		>>> compact_hostnames(['server-1-2', 'server-1-1', 'server-2-2'])
+		['server-1-[1-2]', 'server-2-2']
+		>>> compact_hostnames(['test1-a', 'test2-a'])
+		['test[1-2]-a']
+		>>> compact_hostnames(['sub-s1', 'sub-s2'])
+		['sub-s[1-2]']
+	"""
+	sumDic = __generateSumDic(Hostnames)
+	filteredSumDic = __filterSumDic(sumDic)
+	lastFilteredSumDicLen = len(filteredSumDic) + 1
+	while lastFilteredSumDicLen > len(filteredSumDic):
+		lastFilteredSumDicLen = len(filteredSumDic)
+		filteredSumDic = __filterSumDic(filteredSumDic)
+	rtnSet = set()
+	for sumHash in filteredSumDic:
+		for hostnameTokens in filteredSumDic[sumHash]:
+			hostnameGroupDic = filteredSumDic[sumHash][hostnameTokens]
+			hostnameList = list(hostnameTokens)
+			for tokenIndex, tokenLength in hostnameGroupDic:
+				startToken, endToken = hostnameGroupDic[(tokenIndex, tokenLength)]
+				if tokenLength:
+					hostnameList[tokenIndex] = f'[{startToken:0{tokenLength}d}-{endToken:0{tokenLength}d}]'
+				else:
+					hostnameList[tokenIndex] = f'[{startToken}-{endToken}]'
+			rtnSet.add(''.join(hostnameList))
+	return frozenset(rtnSet)
+
+# ------------ Expanding Hostnames ----------------
 @cache_decorator
-def getIP(hostname,local=False):
+def __validate_expand_hostname(hostname):
 	'''
-	Get the IP address of the hostname
+	Validate the hostname and expand it if it is a range of IP addresses
 
 	Args:
-		hostname (str): The hostname
+		hostname (str): The hostname to be validated and expanded
 
 	Returns:
-		str: The IP address of the hostname
+		list: A list of valid hostnames
 	'''
-	global _etc_hosts
-	# First we check if the hostname is an IP address
-	try:
-		ipaddress.ip_address(hostname)
-		return hostname
-	except ValueError:
-		pass
-	# Then we check /etc/hosts
-	if not _etc_hosts and os.path.exists('/etc/hosts'):
-		with open('/etc/hosts','r') as f:
-			for line in f:
-				if line.startswith('#') or not line.strip():
-					continue
-				#ip, host = line.split()[:2]
-				chunks = line.split()
-				if len(chunks) < 2:
-					continue
-				ip = chunks[0]
-				for host in chunks[1:]:
-					_etc_hosts[host] = ip
-	if hostname in _etc_hosts:
-		return _etc_hosts[hostname]
-	if local:
-		return None
-	# Then we check the DNS
-	try:
-		return socket.gethostbyname(hostname)
-	except:
-		return None
-	
+	global _no_env
+	# maybe it is just defined in ./target_files/hosts.sh and exported to the environment
+	# we will try to get the valid host name from the environment
+	hostname = hostname.strip().strip('$')
+	if getIP(hostname,local=True):
+		return [hostname]
+	elif not _no_env and hostname in os.environ:
+		# we will expand these hostnames again
+		return expand_hostnames(frozenset(os.environ[hostname].split(',')))
+	elif hostname in readEnvFromFile():
+		# we will expand these hostnames again
+		return expand_hostnames(frozenset(readEnvFromFile()[hostname].split(',')))
+	elif getIP(hostname,local=False):
+		return [hostname]
+	else:
+		eprint(f"Error: {hostname!r} is not a valid hostname or IP address!")
+		global __mainReturnCode
+		__mainReturnCode += 1
+		global __failedHosts
+		__failedHosts.add(hostname)
+		return []
+
 @cache_decorator
-def readEnvFromFile(environemnt_file = ''):
+def __expandIPv4Address(hosts):
 	'''
-	Read the environment variables from env_file
+	Expand the IP address range in the hosts list
+
+	Args:
+		hosts (list): A list of IP addresses or IP address ranges
+
 	Returns:
-		dict: A dictionary of environment variables
+		list: A list of expanded IP addresses
 	'''
-	global env
-	try:
-		if env:
-			return env
-	except:
-		env = {}
-	global _env_file
-	if environemnt_file:
-		envf = environemnt_file
-	else:
-		envf = _env_file if _env_file else DEFAULT_ENV_FILE
-	if os.path.exists(envf):
-		with open(envf,'r') as f:
-			for line in f:
-				if line.startswith('#') or not line.strip():
-					continue
-				key, value = line.replace('export ', '', 1).strip().split('=', 1)
-				key = key.strip().strip('"').strip("'")
-				value = value.strip().strip('"').strip("'")
-				# avoid infinite recursion
-				if key != value:
-					env[key] = value.strip('"').strip("'")
-	return env
+	expandedHosts = []
+	expandedHost = []
+	for host in hosts:
+		host = host.replace('[','').replace(']','').strip()
+		octets = host.split('.')
+		expandedOctets = []
+		for octet in octets:
+			if '-' in octet:
+				# Handle wildcards
+				octetRange = octet.split('-')
+				for i in range(len(octetRange)):
+					if not octetRange[i] or octetRange[i] in __wildCharacters:
+						if i == 0:
+							octetRange[i] = '0'
+						elif i == 1:
+							octetRange[i] = '255'
+				
+				expandedOctets.append([str(i) for i in range(int(octetRange[0]),int(octetRange[1])+1)])
+			elif octet in __wildCharacters:
+				expandedOctets.append([str(i) for i in range(0,256)])
+			else:
+				expandedOctets.append([octet])
+		# handle the first and last subnet addresses
+		if '0' in expandedOctets[-1]:
+			expandedOctets[-1].remove('0')
+		if '255' in expandedOctets[-1]:
+			expandedOctets[-1].remove('255')
+		#print(expandedOctets)
+		# Generate the expanded hosts
+		for ip in list(product(expandedOctets[0],expandedOctets[1],expandedOctets[2],expandedOctets[3])):
+			expandedHost.append('.'.join(ip))
+	expandedHosts.extend(expandedHost)
+	return expandedHosts
 
 @cache_decorator 
-def expand_hostname(text,validate=True):
+def __expand_hostname(text, validate=True):# -> set:
 	'''
 	Expand the hostname range in the text.
-	Will search the string for a range ( [] encloused and non enclosed number ranges).
+	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:
@@ -404,78 +902,55 @@ def expand_hostname(text,validate=True):
 	alphanumeric = string.digits + string.ascii_letters
 	while len(expandinghosts) > 0:
 		hostname = expandinghosts.pop()
-		match = re.search(r'\[(.*?-.*?)\]', hostname)
+		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])
+			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:
+		group = match.group(1)
+		parts = group.split(',')
+		for part in parts:
+			part = part.strip()
+			if '-' in part:
 				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])
+					range_start,_, range_end = part.partition('-')
 				except ValueError:
-					expandedhosts.update(validate_expand_hostname(hostname) if validate else [hostname])
+					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
 
 @cache_decorator
-def expand_hostnames(hosts):
+def expand_hostnames(hosts) -> dict:
 	'''
-	Expand the hostnames in the hosts list
+	Expand the hostnames in the hosts into a dictionary
 
 	Args:
 		hosts (list): A list of hostnames
 
 	Returns:
-		list: A list of expanded hostnames
+		dict: A dictionary of expanded hostnames with key: hostname, value: resolved IP address
 	'''
-	expandedhosts = []
+	expandedhosts = {}
 	if isinstance(hosts, str):
 		hosts = [hosts]
 	for host in hosts:
@@ -485,84 +960,32 @@ def expand_hostnames(hosts):
 		# we seperate the username from the hostname
 		username = None
 		if '@' in host:
-			username, host = host.split('@',1)
+			username, host = host.split('@',1).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|\*|\?))?\]))" 
 		# seperated by .
 		# If so, we expand the IP address range
+		iplist = []
 		if re.match(r'^((((25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])|x|\*|\?)(-((25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])|x|\*|\?))?)|(\[((25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])|x|\*|\?)(-((25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])}|x|\*|\?))?\]))(\.((((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|x|\*|\?)(-((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|x|\*|\?))?)|(\[((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|x|\*|\?)(-((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|x|\*|\?))?\]))){2}(\.(((25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])|x|\*|\?)(-((25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])|x|\*|\?))?)|(\[((25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])|x|\*|\?)(-((25[0-4]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])}|x|\*|\?))?\]))$', host):
-			hostSetToAdd = sorted(expandIPv4Address(frozenset([host])),key=ipaddress.IPv4Address)
+			hostSetToAdd = sorted(__expandIPv4Address(frozenset([host])),key=ipaddress.IPv4Address)
+			iplist = hostSetToAdd
 		else:
-			hostSetToAdd = sorted(expand_hostname(host))
+			hostSetToAdd = sorted(__expand_hostname(host))
+			for host in hostSetToAdd:
+				iplist.append(getIP(host,local=False))
 		if username:
 			# we expand the username
-			username = sorted(expand_hostname(username,validate=False))
+			username = sorted(__expand_hostname(username,validate=False))
 			# we combine the username and hostname
-			hostSetToAdd = [u+'@'+h for u,h in product(username,hostSetToAdd)]
-		expandedhosts.extend(hostSetToAdd)
+			for user in username:
+				[expandedhosts.update({f'{user}@{host}':ip}) for host,ip in zip(hostSetToAdd,iplist)]
+		else:
+			[expandedhosts.update({host:ip}) for host,ip in zip(hostSetToAdd,iplist)]
 	return expandedhosts
 
-@cache_decorator
-def validate_expand_hostname(hostname):
-	'''
-	Validate the hostname and expand it if it is a range of IP addresses
-
-	Args:
-		hostname (str): The hostname to be validated and expanded
-
-	Returns:
-		list: A list of valid hostnames
-	'''
-	global _no_env
-	# maybe it is just defined in ./target_files/hosts.sh and exported to the environment
-	# we will try to get the valid host name from the environment
-	hostname = hostname.strip('$')
-	if getIP(hostname,local=True):
-		return [hostname]
-	elif not _no_env and hostname in os.environ:
-		# we will expand these hostnames again
-		return expand_hostnames(frozenset(os.environ[hostname].split(',')))
-	elif hostname in readEnvFromFile():
-		# we will expand these hostnames again
-		return expand_hostnames(frozenset(readEnvFromFile()[hostname].split(',')))
-	elif getIP(hostname,local=False):
-		return [hostname]
-	else:
-		eprint(f"Error: {hostname} is not a valid hostname or IP address!")
-		global __mainReturnCode
-		__mainReturnCode += 1
-		global __failedHosts
-		__failedHosts.add(hostname)
-		return []
-
-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
-		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 handle_reading_stream(stream,target, host):
+# ------------ Run Command Block ----------------
+def __handle_reading_stream(stream,target, host):
 	'''
 	Read the stream and append the lines to the target list
 
@@ -602,7 +1025,7 @@ def handle_reading_stream(stream,target, host):
 	if current_line:
 		add_line(current_line,target, host, keepLastLine=lastLineCommited)
 
-def handle_writing_stream(stream,stop_event,host):
+def __handle_writing_stream(stream,stop_event,host):
 	'''
 	Write the key presses to the stream
 
@@ -623,8 +1046,9 @@ def handle_writing_stream(stream,stop_event,host):
 		if sentInput < len(__keyPressesIn) - 1 :
 			stream.write(''.join(__keyPressesIn[sentInput]).encode())
 			stream.flush()
-			host.output.append(' $ ' + ''.join(__keyPressesIn[sentInput]).encode().decode().replace('\n', '↵'))
-			host.stdout.append(' $ ' + ''.join(__keyPressesIn[sentInput]).encode().decode().replace('\n', '↵'))
+			line = '> ' + ''.join(__keyPressesIn[sentInput]).encode().decode().replace('\n', '↵')
+			host.output.append(line)
+			host.stdout.append(line)
 			sentInput += 1
 			host.lastUpdateTime = time.time()
 		else:
@@ -639,35 +1063,7 @@ def handle_writing_stream(stream,stop_event,host):
 	#     host.stdout.append(' $ ' + ''.join(__keyPressesIn[-1]).encode().decode().replace('\n', '↵'))
 	return sentInput
 	
-def replace_magic_strings(string,keys,value,case_sensitive=False):
-	'''
-	Replace the magic strings in the host object
-
-	Args:
-		string (str): The string to replace the magic strings
-		keys (list): Search for keys to replace
-		value (str): The value to replace the key
-		case_sensitive (bool, optional): Whether to search for the keys in a case sensitive way. Defaults to False.
-
-	Returns:
-		str: The string with the magic strings replaced
-	'''
-	# verify magic strings have # at the beginning and end
-	newKeys = []
-	for key in keys:
-		if key.startswith('#') and key.endswith('#'):
-			newKeys.append(key)
-		else:
-			newKeys.append('#'+key.strip('#')+'#')
-	# replace the magic strings
-	for key in newKeys:
-		if case_sensitive:
-			string = string.replace(key,value)
-		else:
-			string = re.sub(re.escape(key),value,string,flags=re.IGNORECASE)
-	return string
-
-def ssh_command(host, sem, timeout=60,passwds=None):
+def run_command(host, sem, timeout=60,passwds=None):
 	'''
 	Run the command on the host. Will format the commands accordingly. Main execution function.
 
@@ -706,8 +1102,6 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 		host.command = replace_magic_strings(host.command,['#ID#'],str(id(host)),case_sensitive=False)
 		host.command = replace_magic_strings(host.command,['#I#'],str(host.i),case_sensitive=False)
 		host.command = replace_magic_strings(host.command,['#PASSWD#','#PASSWORD#'],passwds,case_sensitive=False)
-		if host.resolvedName:
-			host.command = replace_magic_strings(host.command,['#RESOLVEDNAME#','#RESOLVED#'],host.resolvedName,case_sensitive=False)
 		host.command = replace_magic_strings(host.command,['#UUID#'],str(host.uuid),case_sensitive=False)
 		formatedCMD = []
 		if host.extraargs and type(host.extraargs) == str:
@@ -720,7 +1114,7 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 			host.interface_ip_prefix = __ipmiiInterfaceIPPrefix if host.ipmi and not host.interface_ip_prefix else host.interface_ip_prefix
 		if host.interface_ip_prefix:
 			try:
-				hostOctets = getIP(host.address,local=False).split('.')
+				hostOctets = host.ip.split('.')
 				prefixOctets = host.interface_ip_prefix.split('.')
 				host.address = '.'.join(prefixOctets[:3]+hostOctets[min(3,len(prefixOctets)):])
 				host.resolvedName = host.username + '@' if host.username else ''
@@ -729,6 +1123,8 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 				host.resolvedName = host.name
 		else:
 			host.resolvedName = host.name
+		if host.resolvedName:
+			host.command = replace_magic_strings(host.command,['#RESOLVEDNAME#','#RESOLVED#'],host.resolvedName,case_sensitive=False)
 		if host.ipmi:
 			if 'ipmitool' in _binPaths:
 				if host.command.startswith('ipmitool '):
@@ -737,6 +1133,8 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 					host.command = host.command.replace(_binPaths['ipmitool'],'')
 				if not host.username:
 					host.username = 'admin'
+				if not host.command:
+					host.command = 'power status'
 				if 'bash' in _binPaths:
 					if passwds:
 						formatedCMD = [_binPaths['bash'],'-c',f'ipmitool -H {host.address} -U {host.username} -P {passwds} {" ".join(extraargs)} {host.command}']
@@ -755,14 +1153,30 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 					host.stderr.append('Ipmitool not found on the local machine! Trying ipmitool on the remote machine...')
 				host.ipmi = False
 				host.interface_ip_prefix = None
-				host.command = 'ipmitool '+host.command if not host.command.startswith('ipmitool ') else host.command
-				ssh_command(host,sem,timeout,passwds)
+				if not host.command:
+					host.command = 'ipmitool power status'
+				else:
+					host.command = 'ipmitool '+host.command if not host.command.startswith('ipmitool ') else host.command
+				run_command(host,sem,timeout,passwds)
 				return
 			else:
 				host.output.append('Ipmitool not found on the local machine! Please install ipmitool to use ipmi mode.')
 				host.stderr.append('Ipmitool not found on the local machine! Please install ipmitool to use ipmi mode.')
 				host.returncode = 1
 				return
+		elif host.bash:
+			if 'bash' in _binPaths:
+				host.output.append('Running command in bash mode, ignoring the hosts...')
+				if __DEBUG_MODE:
+					host.stderr.append('Running command in bash mode, ignoring the hosts...')
+				formatedCMD = [_binPaths['bash'],'-c',host.command]
+			else:
+				host.output.append('Bash not found on the local machine! Using ssh localhost instead...')
+				if __DEBUG_MODE:
+					host.stderr.append('Bash not found on the local machine! Using ssh localhost instead...')
+				host.bash = False
+				host.name = 'localhost'
+				run_command(host,sem,timeout,passwds)
 		else:
 			if host.files:
 				if host.scp:
@@ -828,15 +1242,15 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 			#host.stdout = []
 			proc = subprocess.Popen(formatedCMD,stdout=subprocess.PIPE,stderr=subprocess.PIPE,stdin=subprocess.PIPE)
 			# create a thread to handle stdout
-			stdout_thread = threading.Thread(target=handle_reading_stream, args=(proc.stdout,host.stdout, host), daemon=True)
+			stdout_thread = threading.Thread(target=__handle_reading_stream, args=(proc.stdout,host.stdout, host), daemon=True)
 			stdout_thread.start()
 			# create a thread to handle stderr
 			#host.stderr = []
-			stderr_thread = threading.Thread(target=handle_reading_stream, args=(proc.stderr,host.stderr, host), daemon=True)
+			stderr_thread = threading.Thread(target=__handle_reading_stream, args=(proc.stderr,host.stderr, host), daemon=True)
 			stderr_thread.start()
 			# create a thread to handle stdin
 			stdin_stop_event = threading.Event()
-			stdin_thread = threading.Thread(target=handle_writing_stream, args=(proc.stdin,stdin_stop_event, host), daemon=True)
+			stdin_thread = threading.Thread(target=__handle_writing_stream, args=(proc.stdin,stdin_stop_event, host), daemon=True)
 			stdin_thread.start()
 			# Monitor the subprocess and terminate it after the timeout
 			host.lastUpdateTime = time.time()
@@ -887,9 +1301,9 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 				except subprocess.TimeoutExpired:
 					pass
 				if stdout:
-					handle_reading_stream(io.BytesIO(stdout),host.stdout, host)
+					__handle_reading_stream(io.BytesIO(stdout),host.stdout, host)
 				if stderr:
-					handle_reading_stream(io.BytesIO(stderr),host.stderr, host)
+					__handle_reading_stream(io.BytesIO(stderr),host.stderr, host)
 				# if the last line in host.stderr is Connection to * closed., we will remove it
 			host.returncode = proc.poll()
 			if not host.returncode:
@@ -918,7 +1332,7 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 		host.ipmi = False
 		host.interface_ip_prefix = None
 		host.command = 'ipmitool '+host.command if not host.command.startswith('ipmitool ') else host.command
-		ssh_command(host,sem,timeout,passwds)
+		run_command(host,sem,timeout,passwds)
 	# If transfering files, we will try again using scp if rsync connection is not successful
 	if host.files and not host.scp and not useScp and host.returncode != 0 and host.stderr:
 		host.stderr = []
@@ -927,11 +1341,12 @@ def ssh_command(host, sem, timeout=60,passwds=None):
 		if __DEBUG_MODE:
 			host.stderr.append('Rsync connection failed! Trying SCP connection...')
 		host.scp = True
-		ssh_command(host,sem,timeout,passwds)
+		run_command(host,sem,timeout,passwds)
 
+# ------------ Start Threading Block ----------------
 def start_run_on_hosts(hosts, timeout=60,password=None,max_connections=4 * os.cpu_count()):
 	'''
-	Start running the command on the hosts. Wrapper function for ssh_command
+	Start running the command on the hosts. Wrapper function for run_command
 
 	Args:
 		hosts (list): A list of Host objects
@@ -945,12 +1360,13 @@ def start_run_on_hosts(hosts, timeout=60,password=None,max_connections=4 * os.cp
 	if len(hosts) == 0:
 		return []
 	sem = threading.Semaphore(max_connections)  # Limit concurrent SSH sessions
-	threads = [threading.Thread(target=ssh_command, args=(host, sem,timeout,password), daemon=True) for host in hosts]
+	threads = [threading.Thread(target=run_command, args=(host, sem,timeout,password), daemon=True) for host in hosts]
 	for thread in threads:
 		thread.start()
 	return threads
 
-def get_hosts_to_display (hosts, max_num_hosts, hosts_to_display = None):
+# ------------ Display Block ----------------
+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.
 
@@ -982,14 +1398,7 @@ def get_hosts_to_display (hosts, max_num_hosts, hosts_to_display = None):
 			host.printedLines = 0
 	return new_hosts_to_display , {'running':len(running_hosts), 'failed':len(failed_hosts), 'finished':len(finished_hosts), 'waiting':len(waiting_hosts)}
 
-# Error: integer division or modulo by zero, Reloading Configuration: min_char_len=40, min_line_len=1, single_window=False with window size (61, 186) and 1 hosts...
-# Traceback (most recent call last):
-#   File "/usr/local/lib/python3.11/site-packages/multiSSH3.py", line 1030, in generate_display
-#     host_window_height = max_y // num_hosts_y
-#                          ~~~~~~^^~~~~~~~~~~~~
-# ZeroDivisionError: integer division or modulo by zero
-
-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'):
+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:
 		org_dim = stdscr.getmaxyx()
 		new_configured = True
@@ -1016,7 +1425,7 @@ def generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min_c
 		max_num_hosts = max_num_hosts_x * max_num_hosts_y
 		if max_num_hosts < 1:
 			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal too small to display any hosts')
-		hosts_to_display , host_stats = get_hosts_to_display(hosts, max_num_hosts)
+		hosts_to_display , host_stats = _get_hosts_to_display(hosts, max_num_hosts)
 		if len(hosts_to_display) == 0:
 			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'No hosts to display')
 		# Now we calculate the actual number of hosts we will display for x and y
@@ -1195,7 +1604,7 @@ def generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min_c
 			if time.perf_counter() - last_refresh_time < 0.01:
 				time.sleep(max(0,0.01 - time.perf_counter() + last_refresh_time))
 			#stdscr.clear()
-			hosts_to_display, host_stats = get_hosts_to_display(hosts, max_num_hosts,hosts_to_display)
+			hosts_to_display, host_stats = _get_hosts_to_display(hosts, max_num_hosts,hosts_to_display)
 			for host_window, host in zip(host_windows, hosts_to_display):
 				# we will only update the window if there is new output or the window is not fully printed
 				if new_configured or host.printedLines < len(host.output):
@@ -1272,7 +1681,7 @@ def curses_print(stdscr, hosts, threads, min_char_len = DEFAULT_CURSES_MINIMUM_C
 
 	params = (-1,0 , min_char_len, min_line_len, single_window,'new config')
 	while params:
-		params = generate_display(stdscr, hosts, *params)
+		params = __generate_display(stdscr, hosts, *params)
 		if not params:
 			break
 		if not any([host.returncode is None for host in hosts]):
@@ -1295,7 +1704,7 @@ def curses_print(stdscr, hosts, threads, min_char_len = DEFAULT_CURSES_MINIMUM_C
 		time.sleep(0.01)
 		#time.sleep(0.25)
 
-
+# ------------ Generate Output Block ----------------
 def print_output(hosts,usejson = False,quiet = False,greppable = False):
 	'''
 	Print / generate the output of the hosts to the terminal
@@ -1316,23 +1725,18 @@ def print_output(hosts,usejson = False,quiet = False,greppable = False):
 		#print(json.dumps([dict(host) for host in hosts],indent=4))
 		rtnStr = json.dumps(hosts,indent=4)
 	elif greppable:
-		outputs = {}
-		# transform hosts to dictionaries
-		for host in hosts:
-			hostPrintOut = f" | cmd: {host['command']} | stdout: "+'↵ '.join(host['stdout'])
-			if host['stderr']:
-				if host['stderr'][0].strip().startswith('ssh: connect to host '):
-					host['stderr'][0] = 'SSH not reachable!'
-				hostPrintOut += " | stderr: "+'↵ '.join(host['stderr'])
-			hostPrintOut += f" | return_code: {host['returncode']}"
-			if hostPrintOut not in outputs:
-				outputs[hostPrintOut] = [host['name']]
-			else:
-				outputs[hostPrintOut].append(host['name'])
+		# transform hosts to a 2d list
 		rtnStr = '*'*80+'\n'
-		for output, hosts in outputs.items():
-			rtnStr += f"{','.join(hosts)}{output}\n"
-			rtnStr += '*'*80+'\n'
+		rtnList = [['host_name','return_code','output_type','output']]
+		for host in hosts:
+			#header = f"{host['name']} | rc: {host['returncode']} | "
+			for line in host['stdout']:
+				rtnList.append([host['name'],f"rc: {host['returncode']}",'stdout',line])
+			for line in host['stderr']:
+				rtnList.append([host['name'],f"rc: {host['returncode']}",'stderr',line])
+			rtnList.append(['','','',''])
+		rtnStr += pretty_format_table(rtnList)
+		rtnStr += '*'*80+'\n'
 		if __keyPressesIn[-1]:
 			CMDsOut = [''.join(cmd).encode('unicode_escape').decode().replace('\\n', '↵') for cmd in __keyPressesIn if cmd]
 			rtnStr += 'User Inputs: '+ '\nUser Inputs: '.join(CMDsOut)
@@ -1348,20 +1752,26 @@ def print_output(hosts,usejson = False,quiet = False,greppable = False):
 			if host['stderr']:
 				if host['stderr'][0].strip().startswith('ssh: connect to host '):
 					host['stderr'][0] = 'SSH not reachable!'
+				elif host['stderr'][-1].strip().endswith('Connection timed out'):
+					host['stderr'][-1] = 'SSH connection timed out!'
+				elif host['stderr'][-1].strip().endswith('No route to host'):
+					host['stderr'][-1] = 'Cannot find host!'
 				hostPrintOut += "\n  stderr:\n  "+'\n    '.join(host['stderr'])
 			hostPrintOut += f"\n  return_code: {host['returncode']}"
-			if hostPrintOut not in outputs:
-				outputs[hostPrintOut] = [host['name']]
-			else:
-				outputs[hostPrintOut].append(host['name'])
+			outputs.setdefault(hostPrintOut, set()).add(host['name'])
 		rtnStr = ''
-		for output, hosts in outputs.items():
+		for output, hostSet in outputs.items():
+			hostSet = frozenset(hostSet)
+			compact_hosts = compact_hostnames(hostSet)
+			if set(expand_hostnames(compact_hosts)) != set(expand_hostnames(hostSet)):
+				eprint(f"Error compacting hostnames: {hostSet} -> {compact_hosts}")
+				compact_hosts = hostSet
 			if __global_suppress_printout:
-				rtnStr += f'Abnormal returncode produced by {hosts}:\n'
+				rtnStr += f'Abnormal returncode produced by {",".join(compact_hosts)}:\n'
 				rtnStr += output+'\n'
 			else:
 				rtnStr += '*'*80+'\n'
-				rtnStr += f"These hosts: {hosts} have a response of:\n"
+				rtnStr += f'These hosts: "{",".join(sorted(compact_hosts))}" have a response of:\n'
 				rtnStr += output+'\n'
 		if not __global_suppress_printout or outputs:
 			rtnStr += '*'*80+'\n'
@@ -1379,62 +1789,12 @@ def print_output(hosts,usejson = False,quiet = False,greppable = False):
 		print(rtnStr)
 	return rtnStr
 
-# sshConfigged = False
-# def verify_ssh_config():
-# 	'''
-# 	Verify that ~/.ssh/config exists and contains the line "StrictHostKeyChecking no"
-
-# 	Args:
-# 		None
-
-# 	Returns:
-# 		None
-# 	'''
-# 	global sshConfigged
-# 	if not sshConfigged:
-# 		# first we make sure ~/.ssh/config exists
-# 		config = ''
-# 		if not os.path.exists(os.path.expanduser('~/.ssh')):
-# 			os.makedirs(os.path.expanduser('~/.ssh'))
-# 		if os.path.exists(os.path.expanduser('~/.ssh/config')):
-# 			with open(os.path.expanduser('~/.ssh/config'),'r') as f:
-# 				config = f.read()
-# 		if config:
-# 			if 'StrictHostKeyChecking no' not in config:
-# 				with open(os.path.expanduser('~/.ssh/config'),'a') as f:
-# 					f.write('\nHost *\n\tStrictHostKeyChecking no\n')
-# 		else:
-# 			with open(os.path.expanduser('~/.ssh/config'),'w') as f:
-# 				f.write('Host *\n\tStrictHostKeyChecking no\n')
-# 		sshConfigged = True
-
-def signal_handler(sig, frame):
-	'''
-	Handle the Ctrl C signal
-
-	Args:
-		sig (int): The signal
-		frame (frame): The frame
-
-	Returns:
-		None
-	'''
-	global _emo
-	if not _emo:
-		eprint('Ctrl C caught, exiting...')
-		_emo = True
-	else:
-		eprint('Ctrl C caught again, exiting immediately!')
-		# wait for 0.1 seconds to allow the threads to exit
-		time.sleep(0.1)
-		os.system(f'pkill -ef {os.path.basename(__file__)}')
-		sys.exit(0)
-
+# ------------ Run / Process Hosts Block ----------------
 def processRunOnHosts(timeout, password, max_connections, hosts, returnUnfinished, nowatch, json, called, greppable,unavailableHosts,willUpdateUnreachableHosts,curses_min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, curses_min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,single_window = DEFAULT_SINGLE_WINDOW):
 	global __globalUnavailableHosts
 	global _no_env
 	threads = start_run_on_hosts(hosts, timeout=timeout,password=password,max_connections=max_connections)
-	if not nowatch and threads and not returnUnfinished and any([thread.is_alive() for thread in threads]) and sys.stdout.isatty() and os.get_terminal_size() and os.get_terminal_size().columns > 10:
+	if __curses_available and not nowatch and threads and not returnUnfinished and any([thread.is_alive() for thread in threads]) and sys.stdout.isatty() and os.get_terminal_size() and os.get_terminal_size().columns > 10:
 		curses.wrapper(curses_print, hosts, threads, min_char_len = curses_min_char_len, min_line_len = curses_min_line_len, single_window = single_window)
 	if not returnUnfinished:
 		# wait until all hosts have a return code
@@ -1445,7 +1805,7 @@ def processRunOnHosts(timeout, password, max_connections, hosts, returnUnfinishe
 	# update the unavailable hosts and global unavailable hosts
 	if willUpdateUnreachableHosts:
 		unavailableHosts = set(unavailableHosts)
-		unavailableHosts.update([host.name for host in hosts if host.stderr and ('No route to host' in host.stderr[0].strip() or host.stderr[0].strip().startswith('Timeout!'))])
+		unavailableHosts.update([host.name for host in hosts if host.stderr and ('No route to host' in host.stderr[0].strip() or (host.stderr[-1].strip().startswith('Timeout!') and host.returncode == 124))])
 		# reachable hosts = all hosts - unreachable hosts
 		reachableHosts = set([host.name for host in hosts]) - unavailableHosts
 		if __DEBUG_MODE:
@@ -1482,12 +1842,13 @@ def processRunOnHosts(timeout, password, max_connections, hosts, returnUnfinishe
 				os.replace(os.path.join(tempfile.gettempdir(),'__multiSSH3_UNAVAILABLE_HOSTS.csv.new'),os.path.join(tempfile.gettempdir(),'__multiSSH3_UNAVAILABLE_HOSTS.csv'))
 				
 		except Exception as e:
-			eprint(f'Error writing to temporary file: {e}')
+			eprint(f'Error writing to temporary file: {e!r}')
 
 	# print the output, if the output of multiple hosts are the same, we aggragate them
 	if not called:
 		print_output(hosts,json,greppable=greppable)
 
+# ------------ Stringfy Block ----------------
 @cache_decorator
 def formHostStr(host) -> str:
 	"""
@@ -1511,7 +1872,6 @@ def formHostStr(host) -> str:
 	host = ','.join(host)
 	return host
 
-
 @cache_decorator
 def __formCommandArgStr(oneonone = DEFAULT_ONE_ON_ONE, timeout = DEFAULT_TIMEOUT,password = DEFAULT_PASSWORD,
 						 nowatch = DEFAULT_NO_WATCH,json = DEFAULT_JSON_MODE,max_connections=DEFAULT_MAX_CONNECTIONS,
@@ -1519,12 +1879,14 @@ def __formCommandArgStr(oneonone = DEFAULT_ONE_ON_ONE, timeout = DEFAULT_TIMEOUT
 						 scp=DEFAULT_SCP,gather_mode = False,username=DEFAULT_USERNAME,extraargs=DEFAULT_EXTRA_ARGS,skipUnreachable=DEFAULT_SKIP_UNREACHABLE,
 						 no_env=DEFAULT_NO_ENV,greppable=DEFAULT_GREPPABLE_MODE,skip_hosts = DEFAULT_SKIP_HOSTS,
 						 file_sync = False, error_only = DEFAULT_ERROR_ONLY, identity_file = DEFAULT_IDENTITY_FILE,
+						 copy_id = False,
 						 shortend = False) -> str:
 	argsList = []
 	if oneonone: argsList.append('--oneonone' if not shortend else '-11')
 	if timeout and timeout != DEFAULT_TIMEOUT: argsList.append(f'--timeout={timeout}' if not shortend else f'-t={timeout}')
 	if password and password != DEFAULT_PASSWORD: argsList.append(f'--password="{password}"' if not shortend else f'-p="{password}"')
 	if identity_file and identity_file != DEFAULT_IDENTITY_FILE: argsList.append(f'--key="{identity_file}"' if not shortend else f'-k="{identity_file}"')
+	if copy_id: argsList.append('--copy_id' if not shortend else '-ci')
 	if nowatch: argsList.append('--nowatch' if not shortend else '-q')
 	if json: argsList.append('--json' if not shortend else '-j')
 	if max_connections and max_connections != DEFAULT_MAX_CONNECTIONS: argsList.append(f'--max_connections={max_connections}' if not shortend else f'-m={max_connections}')
@@ -1550,6 +1912,7 @@ def getStrCommand(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAULT_ONE_O
 						 no_env=DEFAULT_NO_ENV,greppable=DEFAULT_GREPPABLE_MODE,willUpdateUnreachableHosts=_DEFAULT_UPDATE_UNREACHABLE_HOSTS,no_start=_DEFAULT_NO_START,
 						 skip_hosts = DEFAULT_SKIP_HOSTS, curses_min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, curses_min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,
 						 single_window = DEFAULT_SINGLE_WINDOW,file_sync = False,error_only = DEFAULT_ERROR_ONLY, identity_file = DEFAULT_IDENTITY_FILE,
+						 copy_id = False,
 						 shortend = False):
 	hosts = hosts if type(hosts) == str else frozenset(hosts)
 	hostStr = formHostStr(hosts)
@@ -1559,17 +1922,20 @@ def getStrCommand(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAULT_ONE_O
 						 files = files,ipmi = ipmi,interface_ip_prefix = interface_ip_prefix,scp=scp,gather_mode = gather_mode,
 						 username=username,extraargs=extraargs,skipUnreachable=skipUnreachable,no_env=no_env,
 						 greppable=greppable,skip_hosts = skip_hosts, file_sync = file_sync,error_only = error_only, identity_file = identity_file,
+						 copy_id = copy_id,
 						 shortend = shortend)
 	commandStr = '"' + '" "'.join(commands) + '"' if commands else ''
 	return f'multissh {argsStr} {hostStr} {commandStr}'
 
+# ------------ Main Block ----------------
 def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAULT_ONE_ON_ONE, timeout = DEFAULT_TIMEOUT,password = DEFAULT_PASSWORD,
 						 nowatch = DEFAULT_NO_WATCH,json = DEFAULT_JSON_MODE,called = _DEFAULT_CALLED,max_connections=DEFAULT_MAX_CONNECTIONS,
 						 files = None,ipmi = DEFAULT_IPMI,interface_ip_prefix = DEFAULT_INTERFACE_IP_PREFIX,returnUnfinished = _DEFAULT_RETURN_UNFINISHED,
 						 scp=DEFAULT_SCP,gather_mode = False,username=DEFAULT_USERNAME,extraargs=DEFAULT_EXTRA_ARGS,skipUnreachable=DEFAULT_SKIP_UNREACHABLE,
 						 no_env=DEFAULT_NO_ENV,greppable=DEFAULT_GREPPABLE_MODE,willUpdateUnreachableHosts=_DEFAULT_UPDATE_UNREACHABLE_HOSTS,no_start=_DEFAULT_NO_START,
 						 skip_hosts = DEFAULT_SKIP_HOSTS, curses_min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, curses_min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,
-						 single_window = DEFAULT_SINGLE_WINDOW,file_sync = False,error_only = DEFAULT_ERROR_ONLY,quiet = False,identity_file = DEFAULT_IDENTITY_FILE):
+						 single_window = DEFAULT_SINGLE_WINDOW,file_sync = False,error_only = DEFAULT_ERROR_ONLY,quiet = False,identity_file = DEFAULT_IDENTITY_FILE,
+						 copy_id = False):
 	f'''
 	Run the command on the hosts, aka multissh. main function
 
@@ -1604,6 +1970,7 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 		error_only (bool, optional): Whether to only print the error output. Defaults to {DEFAULT_ERROR_ONLY}.
 		quiet (bool, optional): Whether to suppress all verbose printout, added for compatibility, avoid using. Defaults to False.
 		identity_file (str, optional): The identity file to use for the ssh connection. Defaults to {DEFAULT_IDENTITY_FILE}.
+		copy_id (bool, optional): Whether to copy the id to the hosts. Defaults to False.
 
 	Returns:
 		list: A list of Host objects
@@ -1625,17 +1992,20 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 		elif checkTime > 3600:
 			checkTime = 3600
 		try:
+			readed = False
 			if 0 < time.time() - os.path.getmtime(os.path.join(tempfile.gettempdir(),'__multiSSH3_UNAVAILABLE_HOSTS.csv')) < checkTime:
-				if not __global_suppress_printout:
-					eprint(f"Reading unavailable hosts from the file {os.path.join(tempfile.gettempdir(),'__multiSSH3_UNAVAILABLE_HOSTS.csv')}")
+
 				with open(os.path.join(tempfile.gettempdir(),'__multiSSH3_UNAVAILABLE_HOSTS.csv'),'r') as f:
 					for line in f:
 						line = line.strip()
 						if line and ',' in line and len(line.split(',')) >= 2 and line.split(',')[0] and line.split(',')[1].isdigit():
 							if int(line.split(',')[1]) > time.time() - checkTime:
 								__globalUnavailableHosts.add(line.split(',')[0])
+								readed = True
+			if readed and not __global_suppress_printout:
+				eprint(f"Read unavailable hosts from the file {os.path.join(tempfile.gettempdir(),'__multiSSH3_UNAVAILABLE_HOSTS.csv')}")
 		except Exception as e:
-			eprint(f"Warning: Unable to read the unavailable hosts from the file {os.path.join(tempfile.gettempdir(),'__multiSSH3_UNAVAILABLE_HOSTS.csv')}")
+			eprint(f"Warning: Unable to read the unavailable hosts from the file {os.path.join(tempfile.gettempdir(),'__multiSSH3_UNAVAILABLE_HOSTS.csv')!r}")
 			eprint(str(e))
 	elif '__multiSSH3_UNAVAILABLE_HOSTS' in readEnvFromFile():
 		__globalUnavailableHosts.update(readEnvFromFile()['__multiSSH3_UNAVAILABLE_HOSTS'].split(','))
@@ -1654,13 +2024,12 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 			commands = [' '.join(command) if not type(command) == str else command for command in commands]
 		except:
 			pass
-			eprint(f"Warning: commands should ideally be a list of strings. Now mssh had failed to convert {commands} to a list of strings. Continuing anyway but expect failures.")
+			eprint(f"Warning: commands should ideally be a list of strings. Now mssh had failed to convert {commands!r} to a list of strings. Continuing anyway but expect failures.")
 	#verify_ssh_config()
 	# load global unavailable hosts only if the function is called (so using --repeat will not load the unavailable hosts again)
 	if called:
 		# if called,
 		# if skipUnreachable is not set, we default to skip unreachable hosts within one command call
-		__global_suppress_printout = True
 		if skipUnreachable is None:
 			skipUnreachable = True
 		if skipUnreachable:
@@ -1694,12 +2063,37 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 				if '@' not in host:
 					skipHostStr[i] = userStr + host
 			skipHostStr = ','.join(skipHostStr)
-	targetHostsList = expand_hostnames(frozenset(hostStr.split(',')))
+	targetHostDic = expand_hostnames(frozenset(hostStr.split(',')))
 	if __DEBUG_MODE:
-		eprint(f"Target hosts: {targetHostsList}")
-	skipHostsList = expand_hostnames(frozenset(skipHostStr.split(',')))
-	if skipHostsList:
-		eprint(f"Skipping hosts: {skipHostsList}")
+		eprint(f"Target hosts: {targetHostDic!r}")
+	skipHostsDic = expand_hostnames(frozenset(skipHostStr.split(',')))
+	if skipHostsDic:
+		eprint(f"Skipping hosts: {skipHostsDic!r}")
+	skipHostSet = set(skipHostsDic).union(skipHostsDic.values())
+	if copy_id:
+		if 'ssh-copy-id' in _binPaths:
+			# we will copy the id to the hosts
+			hosts = []
+			for host in targetHostDic:
+				if host in skipHostSet or targetHostDic[host] in skipHostSet: continue
+				command = f"{_binPaths['ssh-copy-id']} "
+				if identity_file:
+					command = f"{command}-i {identity_file} "
+				if username:
+					command =  f"{command} {username}@"
+				command = f"{command}{host}"
+				if password and 'sshpass' in _binPaths:
+					command = f"{_binPaths['sshpass']} -p {password} {command}"
+					hosts.append(Host(host, command,identity_file=identity_file,bash=True,ip = targetHostDic[host]))
+				else:
+					eprint(f"> {command}")
+					os.system(command)
+			if hosts:
+				processRunOnHosts(timeout, password, max_connections, hosts, returnUnfinished, nowatch, json, called, greppable,unavailableHosts,willUpdateUnreachableHosts,curses_min_char_len = curses_min_char_len, curses_min_line_len = curses_min_line_len,single_window=single_window)
+		else:
+			eprint(f"Warning: ssh-copy-id not found in {_binPaths} , skipping copy id to the hosts")
+		if not commands:
+			sys.exit(0)
 	if files and not commands:
 		# if files are specified but not target dir, we default to file sync mode
 		file_sync = True
@@ -1716,7 +2110,7 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 				except:
 					pathSet.update(glob.glob(file,recursive=True))
 			if not pathSet:
-				eprint(f'Warning: No source files at {files} are found after resolving globs!')
+				eprint(f'Warning: No source files at {files!r} are found after resolving globs!')
 				sys.exit(66)
 		else:
 			pathSet = set(files)
@@ -1727,29 +2121,29 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 		else:
 			files = list(pathSet)
 		if __DEBUG_MODE:
-			eprint(f"Files: {files}")
+			eprint(f"Files: {files!r}")
 	if oneonone:
 		hosts = []
-		if len(commands) != len(targetHostsList) - len(skipHostsList):
+		if len(commands) != len(set(targetHostDic) - set(skipHostSet)):
 			eprint("Error: the number of commands must be the same as the number of hosts")
 			eprint(f"Number of commands: {len(commands)}")
-			eprint(f"Number of hosts: {len(targetHostsList - skipHostsList)}")
+			eprint(f"Number of hosts: {len(set(targetHostDic) - set(skipHostSet))}")
 			sys.exit(255)
 		if not __global_suppress_printout:
 			eprint('-'*80)
 			eprint("Running in one on one mode")
-		for host, command in zip(targetHostsList, commands):
-			if not ipmi and skipUnreachable and host.strip() in unavailableHosts:
+		for host, command in zip(targetHostDic, commands):
+			if not ipmi and skipUnreachable and host in unavailableHosts:
 				eprint(f"Skipping unavailable host: {host}")
 				continue
-			if host.strip() in skipHostsList: continue
+			if host in skipHostSet or targetHostDic[host] in skipHostSet: continue
 			if file_sync:
-				hosts.append(Host(host.strip(), os.path.dirname(command)+os.path.sep, files = [command],ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file))
+				hosts.append(Host(host, os.path.dirname(command)+os.path.sep, files = [command],ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip = targetHostDic[host]))
 			else:
-				hosts.append(Host(host.strip(), command, files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file))
+				hosts.append(Host(host, command, files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip=targetHostDic[host]))
 			if not __global_suppress_printout: 
-				eprint(f"Running command: {command} on host: {host}")
-		if not __global_suppress_printout: print('-'*80)
+				eprint(f"Running command: {command!r} on host: {host!r}")
+		if not __global_suppress_printout: eprint('-'*80)
 		if not no_start: processRunOnHosts(timeout, password, max_connections, hosts, returnUnfinished, nowatch, json, called, greppable,unavailableHosts,willUpdateUnreachableHosts,curses_min_char_len = curses_min_char_len, curses_min_line_len = curses_min_line_len,single_window=single_window)
 		return hosts
 	else:
@@ -1757,20 +2151,19 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 		if not commands:
 			# run in interactive mode ssh mode
 			hosts = []
-			for host in targetHostsList:
-				if not ipmi and skipUnreachable and host.strip() in unavailableHosts:
+			for host in targetHostDic:
+				if not ipmi and skipUnreachable and host in unavailableHosts:
 					if not __global_suppress_printout: print(f"Skipping unavailable host: {host}")
 					continue
-				if host.strip() in skipHostsList: continue
+				if host in skipHostSet or targetHostDic[host] in skipHostSet: continue
+				# TODO: use ip to determine if we skip the host or not, also for unavailable hosts
 				if file_sync:
 					eprint(f"Error: file sync mode need to be specified with at least one path to sync.")
 					return []
 				elif files:
 					eprint(f"Error: files need to be specified with at least one path to sync")
-				elif ipmi:
-					eprint(f"Error: ipmi mode is not supported in interactive mode")
 				else:
-					hosts.append(Host(host.strip(), '', files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,identity_file=identity_file))
+					hosts.append(Host(host, '', files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,identity_file=identity_file,ip=targetHostDic[host]))
 			if not __global_suppress_printout:
 				eprint('-'*80)
 				eprint(f"Running in interactive mode on hosts: {hostStr}" + (f"; skipping: {skipHostStr}" if skipHostStr else ''))
@@ -1782,15 +2175,15 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 			return hosts
 		for command in commands:
 			hosts = []
-			for host in targetHostsList:
-				if not ipmi and skipUnreachable and host.strip() in unavailableHosts:
+			for host in targetHostDic:
+				if not ipmi and skipUnreachable and host in unavailableHosts:
 					if not __global_suppress_printout: print(f"Skipping unavailable host: {host}")
 					continue
-				if host.strip() in skipHostsList: continue
+				if host in skipHostSet or targetHostDic[host] in skipHostSet: continue
 				if file_sync:
-					hosts.append(Host(host.strip(), os.path.dirname(command)+os.path.sep, files = [command],ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file))
+					hosts.append(Host(host, os.path.dirname(command)+os.path.sep, files = [command],ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip=targetHostDic[host]))
 				else:
-					hosts.append(Host(host.strip(), command, files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file))
+					hosts.append(Host(host, command, files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip=targetHostDic[host]))
 			if not __global_suppress_printout and len(commands) > 1:
 				eprint('-'*80)
 				eprint(f"Running command: {command} on hosts: {hostStr}" + (f"; skipping: {skipHostStr}" if skipHostStr else ''))
@@ -1799,7 +2192,8 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 			allHosts += hosts
 		return allHosts
 
-def get_default_config(args):
+# ------------ Default Config Functions ----------------
+def generate_default_config(args):
 	'''
 	Get the default config
 
@@ -1850,33 +2244,13 @@ def get_default_config(args):
 def write_default_config(args,CONFIG_FILE,backup = True):
 	if backup and os.path.exists(CONFIG_FILE):
 		os.rename(CONFIG_FILE,CONFIG_FILE+'.bak')
-	default_config = get_default_config(args)
+	default_config = generate_default_config(args)
 	# apply the updated defualt_config to __configs_from_file and write that to file
 	__configs_from_file.update(default_config)
 	with open(CONFIG_FILE,'w') as f:
 		json.dump(__configs_from_file,f,indent=4)
 
-def find_ssh_key_file(searchPath = DEDAULT_SSH_KEY_SEARCH_PATH):
-	'''
-	Find the ssh public key file
-
-	Args:
-		searchPath (str, optional): The path to search. Defaults to DEDAULT_SSH_KEY_SEARCH_PATH.
-
-	Returns:
-		str: The path to the ssh key file
-	'''
-	if searchPath:
-		sshKeyPath = searchPath
-	else:
-		sshKeyPath ='~/.ssh'
-	possibleSshKeyFiles = ['id_ed25519','id_ed25519_sk','id_ecdsa','id_ecdsa_sk','id_rsa','id_dsa']
-	for sshKeyFile in possibleSshKeyFiles:
-		if os.path.exists(os.path.expanduser(os.path.join(sshKeyPath,sshKeyFile))):
-			return os.path.join(sshKeyPath,sshKeyFile)
-	return None
-
-
+# ------------ Wrapper Block ----------------
 def main():
 	global _emo
 	global __global_suppress_printout
@@ -1921,12 +2295,15 @@ def main():
 	parser.add_argument("-m","--max_connections", type=int, help=f"Max number of connections to use (default: 4 * cpu_count)", default=DEFAULT_MAX_CONNECTIONS)
 	parser.add_argument("-j","--json", action='store_true', help=F"Output in json format. (default: {DEFAULT_JSON_MODE})", default=DEFAULT_JSON_MODE)
 	parser.add_argument("--success_hosts", action='store_true', help=f"Output the hosts that succeeded in summary as wells. (default: {DEFAULT_PRINT_SUCCESS_HOSTS})", default=DEFAULT_PRINT_SUCCESS_HOSTS)
-	parser.add_argument("-g","--greppable", action='store_true', help=f"Output in greppable format. (default: {DEFAULT_GREPPABLE_MODE})", default=DEFAULT_GREPPABLE_MODE)
-	parser.add_argument("-su","--skip_unreachable", action='store_true', help=f"Skip unreachable hosts. Note: Timedout Hosts are considered unreachable. Note: multiple command sequence will still auto skip unreachable hosts. (default: {DEFAULT_SKIP_UNREACHABLE})", default=DEFAULT_SKIP_UNREACHABLE)
+	parser.add_argument("-g","--greppable",'--table', action='store_true', help=f"Output in greppable format. (default: {DEFAULT_GREPPABLE_MODE})", default=DEFAULT_GREPPABLE_MODE)
+	group = parser.add_mutually_exclusive_group()
+	group.add_argument("-su","--skip_unreachable", action='store_true', help=f"Skip unreachable hosts. Note: Timedout Hosts are considered unreachable. Note: multiple command sequence will still auto skip unreachable hosts. (default: {DEFAULT_SKIP_UNREACHABLE})", default=DEFAULT_SKIP_UNREACHABLE)
+	group.add_argument("-nsu","--no_skip_unreachable",dest = 'skip_unreachable', action='store_false', help=f"Do not skip unreachable hosts. Note: Timedout Hosts are considered unreachable. Note: multiple command sequence will still auto skip unreachable hosts. (default: {not DEFAULT_SKIP_UNREACHABLE})", default=not DEFAULT_SKIP_UNREACHABLE)
+
 	parser.add_argument("-sh","--skip_hosts", type=str, help=f"Skip the hosts in the list. (default: {DEFAULT_SKIP_HOSTS if DEFAULT_SKIP_HOSTS else 'None'})", default=DEFAULT_SKIP_HOSTS)
 	parser.add_argument('--store_config_file', action='store_true', help=f'Store / generate the default config file from command line argument and current config at {CONFIG_FILE}')
 	parser.add_argument('--debug', action='store_true', help='Print debug information')
-	parser.add_argument('--copy-id', action='store_true', help='Copy the ssh id to the hosts')
+	parser.add_argument('-ci','--copy_id', action='store_true', help='Copy the ssh id to the hosts')
 	parser.add_argument("-V","--version", action='version', version=f'%(prog)s {version} with [ {", ".join(_binPaths.keys())} ] by {AUTHOR} ({AUTHOR_EMAIL})')
 	
 	# parser.add_argument('-u', '--user', metavar='user', type=str, nargs=1,
@@ -1936,12 +2313,13 @@ def main():
 	# if python version is 3.7 or higher, use parse_intermixed_args
 	try:
 		args = parser.parse_intermixed_args()
-	except:
+	except Exception as e:
+		#eprint(f"Error while parsing arguments: {e!r}")
 		# try to parse the arguments using parse_known_args
 		args, unknown = parser.parse_known_args()
 		# if there are unknown arguments, we will try to parse them again using parse_args
 		if unknown:
-			eprint(f"Warning: Unknown arguments, treating all as commands: {unknown}")
+			eprint(f"Warning: Unknown arguments, treating all as commands: {unknown!r}")
 			args.commands += unknown
 			
 			
@@ -1949,22 +2327,22 @@ def main():
 	if args.store_config_file:
 		try:
 			if os.path.exists(CONFIG_FILE):
-				eprint(f"Warning: {CONFIG_FILE} already exists, what to do? (o/b/n)")
+				eprint(f"Warning: {CONFIG_FILE!r} already exists, what to do? (o/b/n)")
 				eprint(f"o:  Overwrite the file")
-				eprint(f"b:  Rename the current config file at {CONFIG_FILE}.bak forcefully and write the new config file (default)")
+				eprint(f"b:  Rename the current config file at {CONFIG_FILE!r}.bak forcefully and write the new config file (default)")
 				eprint(f"n:  Do nothing")
 				inStr = input_with_timeout_and_countdown(10)
 				if (not inStr) or inStr.lower().strip().startswith('b'):
 					write_default_config(args,CONFIG_FILE,backup = True)
-					eprint(f"Config file written to {CONFIG_FILE}")
+					eprint(f"Config file written to {CONFIG_FILE!r}")
 				elif inStr.lower().strip().startswith('o'):
 					write_default_config(args,CONFIG_FILE,backup = False)
-					eprint(f"Config file written to {CONFIG_FILE}")
+					eprint(f"Config file written to {CONFIG_FILE!r}")
 			else:
 				write_default_config(args,CONFIG_FILE,backup = True)
-				eprint(f"Config file written to {CONFIG_FILE}")
+				eprint(f"Config file written to {CONFIG_FILE!r}")
 		except Exception as e:
-			eprint(f"Error while writing config file: {e}")
+			eprint(f"Error while writing config file: {e!r}")
 			import traceback
 			eprint(traceback.format_exc())
 		if not args.commands:
@@ -1984,9 +2362,9 @@ def main():
 		inStr = input_with_timeout_and_countdown(3)
 		if (not inStr) or inStr.lower().strip().startswith('1'):
 			args.commands = [" ".join(args.commands)]
-			eprint(f"\nRunning 1 command: {args.commands[0]} on all hosts")
+			eprint(f"\nRunning 1 command: {args.commands[0]!r} on all hosts")
 		elif inStr.lower().strip().startswith('m'):
-			eprint(f"\nRunning multiple commands: {', '.join(args.commands)} on all hosts")
+			eprint(f"\nRunning multiple commands: {', '.join(args.commands)!r} on all hosts")
 		else:
 			sys.exit(0)
 
@@ -1997,26 +2375,7 @@ def main():
 			if os.path.isdir(os.path.expanduser(args.key)):
 				args.key = find_ssh_key_file(args.key)
 			elif not os.path.exists(args.key):
-				eprint(f"Warning: Identity file {args.key} not found. Passing to ssh anyway. Proceed with caution.")
-
-	if args.copy_id:
-		if 'ssh-copy-id' in _binPaths:
-			# we will copy the id to the hosts
-			for host in formHostStr(args.hosts).split(','):
-				command = f"{_binPaths['ssh-copy-id']} "
-				if args.key:
-					command = f"{command}-i {args.key} "
-				if args.username:
-					command =  f"{command} {args.username}@"
-				command = f"{command}{host}"
-				if args.password and 'sshpass' in _binPaths:
-					command = f"{_binPaths['sshpass']} -p {args.password} {command}"
-				eprint(f"> {command}")
-				os.system(command)
-		else:
-			eprint(f"Warning: ssh-copy-id not found in {_binPaths} , skipping copy id to the hosts")
-		if not args.commands:
-			sys.exit(0)
+				eprint(f"Warning: Identity file {args.key!r} not found. Passing to ssh anyway. Proceed with caution.")
 
 	__ipmiiInterfaceIPPrefix = args.ipmi_interface_ip_prefix
 
@@ -2028,7 +2387,8 @@ def main():
 						 nowatch=args.nowatch,json=args.json,called=args.no_output,max_connections=args.max_connections,
 						 files=args.file,file_sync=args.file_sync,ipmi=args.ipmi,interface_ip_prefix=args.interface_ip_prefix,scp=args.scp,gather_mode = args.gather_mode,username=args.username,
 						 extraargs=args.extraargs,skipUnreachable=args.skip_unreachable,no_env=args.no_env,greppable=args.greppable,skip_hosts = args.skip_hosts,
-						 curses_min_char_len = args.window_width, curses_min_line_len = args.window_height,single_window=args.single_window,error_only=args.error_only,identity_file=args.key)
+						 curses_min_char_len = args.window_width, curses_min_line_len = args.window_height,single_window=args.single_window,error_only=args.error_only,identity_file=args.key,
+						 copy_id=args.copy_id)
 		eprint('> ' + cmdStr)
 	if args.error_only:
 		__global_suppress_printout = True
@@ -2044,10 +2404,11 @@ def main():
 							 nowatch=args.nowatch,json=args.json,called=args.no_output,max_connections=args.max_connections,
 							 files=args.file,file_sync=args.file_sync,ipmi=args.ipmi,interface_ip_prefix=args.interface_ip_prefix,scp=args.scp,gather_mode = args.gather_mode,username=args.username,
 							 extraargs=args.extraargs,skipUnreachable=args.skip_unreachable,no_env=args.no_env,greppable=args.greppable,skip_hosts = args.skip_hosts,
-							 curses_min_char_len = args.window_width, curses_min_line_len = args.window_height,single_window=args.single_window,error_only=args.error_only,identity_file=args.key)
+							 curses_min_char_len = args.window_width, curses_min_line_len = args.window_height,single_window=args.single_window,error_only=args.error_only,identity_file=args.key,
+							 copy_id=args.copy_id)
 		#print('*'*80)
 
-		if not __global_suppress_printout: eprint('-'*80)
+		#if not __global_suppress_printout: eprint('-'*80)
 	
 	succeededHosts = set()
 	for host in hosts: