multiCMD 1.13__py3-none-any.whl → 1.16__py3-none-any.whl

{multiCMD-1.13.dist-info → multiCMD-1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: multiCMD
-Version: 1.13
+Version: 1.16
 Summary: Run commands simultaneously
 Home-page: https://github.com/yufei-pan/multiCMD
 Author: Yufei Pan
@@ -8,6 +8,7 @@ Author-email: pan@zopyr.us
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -31,6 +32,10 @@ Can be used in bash scripts for automation actions.
 
 Also able to be imported and act as a wrapper for subprocess.
 
+Use return_object=True with run_commands or run_command to get the Task Object (definition below)
+
+Use quiet=True and wait_for_return=False to create a daemon thread that async updates the return list / objects when return comes 
+
 For each process, it will initialize a thread if using -m/--max_threads > 1
 
 For each thread, it will use subprocess lib to open a process for the command task
@@ -68,8 +73,9 @@ Run multiple commands in parallel
 positional arguments:
   command               commands to run
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
+  -p, --parse           Parse ranged input and expand them into multiple commands
   -t timeout, --timeout timeout
                         timeout for each command
   -m max_threads, --max_threads max_threads
@@ -80,25 +86,27 @@ optional arguments:
 
 ```python
 def run_commands(commands, timeout=0,max_threads=1,quiet=False,dry_run=False,with_stdErr=False,
-				 return_code_only=False,return_object=False):
+				 return_code_only=False,return_object=False, parse = False, wait_for_return = True):
 	'''
 	Run multiple commands in parallel
 
 	@params:
-		commands: A list of commands to run
+		commands: A list of commands to run ( list[str] | list[list[str]] )
 		timeout: The timeout for each command
 		max_threads: The maximum number of threads to use
 		quiet: Whether to suppress output
 		dry_run: Whether to simulate running the commands
-		with_stdErr: Whether to return the standard error output
+		with_stdErr: Whether to append the standard error output to the standard output
 		return_code_only: Whether to return only the return code
 		return_object: Whether to return the Task object
+		parse: Whether to parse ranged input
+		wait_for_return: Whether to wait for the return of the commands
 
 	@returns:
 		list: The output of the commands ( list[None] | list[int] | list[list[str]] | list[Task] )
-	'''
+  '''
 def run_command(command, timeout=0,max_threads=1,quiet=False,dry_run=False,with_stdErr=False,
-				return_code_only=False,return_object=False):
+				return_code_only=False,return_object=False,wait_for_return=True):
 	'''
 	Run a command
 
@@ -108,13 +116,25 @@ def run_command(command, timeout=0,max_threads=1,quiet=False,dry_run=False,with_
 		max_threads: The maximum number of threads to use
 		quiet: Whether to suppress output
 		dry_run: Whether to simulate running the command
-		with_stdErr: Whether to return the standard error output
+		with_stdErr: Whether to append the standard error output to the standard output
 		return_code_only: Whether to return only the return code
 		return_object: Whether to return the Task object
+		wait_for_return: Whether to wait for the return of the command
 
 	@returns:
 		None | int | list[str] | Task: The output of the command
 	'''
+def join_threads(threads=__running_threads,timeout=None):
+	'''
+	Join threads
+
+	@params:
+		threads: The threads to join
+		timeout: The timeout
+
+	@returns:
+		None
+	'''
 def input_with_timeout_and_countdown(timeout, prompt='Please enter your selection'):
 	"""
 	Read an input from the user with a timeout and a countdown.
@@ -160,4 +180,10 @@ def int_to_color(n, brightness_threshold=500):
 	@returns:
 		(int,int,int): The RGB color
 	'''
+class Task:
+	def __init__(self, command):
+		self.command = command
+		self.returncode = None
+		self.stdout = []
+		self.stderr = []
 ```

multiCMD-1.16.dist-info/RECORD

@@ -0,0 +1,7 @@
+multiCMD.py,sha256=4sGtNKYAdZihHWtXbKHLaqLqJrnPVlEbhu8hbT2lxmw,16130
+multiCMD-1.16.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+multiCMD-1.16.dist-info/METADATA,sha256=ZeWIRiZ6OhbiFwoVNxzgxxnxH6Q1HASXJSzOJqfI2sg,5758
+multiCMD-1.16.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+multiCMD-1.16.dist-info/entry_points.txt,sha256=nSLBkYrcUCQxt1w3LIJkvgOhpRYEC0xAPqNG7u4OYs8,89
+multiCMD-1.16.dist-info/top_level.txt,sha256=DSqgftD40G09F3qEjpHRCUNUsGUvGZZG69Sm3YEUiWI,9
+multiCMD-1.16.dist-info/RECORD,,

multiCMD.py

@@ -7,10 +7,14 @@ import sys
 import subprocess
 import select
 import os
+import string
+import re
+import itertools
 
-version = '1.13'
+version = '1.16'
 __version__ = version
 
+__running_threads = []
 class Task:
 	def __init__(self, command):
 		self.command = command
@@ -18,7 +22,65 @@ class Task:
 		self.stdout = []
 		self.stderr = []
 	def __iter__(self):
-		return zip(['command', 'returncode', 'stdout', 'stderr'], [self.name, self.command, self.returncode, self.stdout, self.stderr])
+		return zip(['command', 'returncode', 'stdout', 'stderr'], [self.command, self.returncode, self.stdout, self.stderr])
+	def __repr__(self):
+		return f'Task(command={self.command}, returncode={self.returncode}, stdout={self.stdout}, stderr={self.stderr})'
+	def __str__(self):
+		return str(dict(self))
+
+def _expand_ranges(inStr):
+	'''
+	Expand ranges in a string
+
+	@params:
+		inStr: The string to expand
+
+	@returns:
+		list[str]: The expanded string
+	'''
+	expandingStr = [inStr]
+	expandedList = []
+	# all valid alphanumeric characters
+	alphanumeric = string.digits + string.ascii_letters
+	while len(expandingStr) > 0:
+		currentStr = expandingStr.pop()
+		match = re.search(r'\[(.*?)]', currentStr)
+		if not match:
+			expandedList.append(currentStr)
+			continue
+		group = match.group(1)
+		parts = group.split(',')
+		for part in parts:
+			part = part.strip()
+			if '-' in part:
+				try:
+					range_start,_, range_end = part.partition('-')
+				except ValueError:
+					expandedList.append(currentStr)
+					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)
+						expandingStr.append(currentStr.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):
+						expandingStr.append(currentStr.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):
+							expandingStr.append(currentStr.replace(match.group(0), alphanumeric[i], 1))
+					except ValueError:
+						expandedList.append(currentStr)
+			else:
+				expandingStr.append(currentStr.replace(match.group(0), part, 1))
+	expandedList.reverse()
+	return expandedList
 
 def __handle_stream(stream,target,pre='',post='',quiet=False):
 	'''
@@ -120,11 +182,11 @@ def __run_command(task,sem, timeout=60, quiet=False,dry_run=False,with_stdErr=Fa
 			#host.stdout = []
 			proc = subprocess.Popen(task.command,stdout=subprocess.PIPE,stderr=subprocess.PIPE,stdin=subprocess.PIPE)
 			# create a thread to handle stdout
-			stdout_thread = threading.Thread(target=__handle_stream, args=(proc.stdout,task.stdout,pre,post,quiet))
+			stdout_thread = threading.Thread(target=__handle_stream, args=(proc.stdout,task.stdout,pre,post,quiet),daemon=True)
 			stdout_thread.start()
 			# create a thread to handle stderr
 			#host.stderr = []
-			stderr_thread = threading.Thread(target=__handle_stream, args=(proc.stderr,task.stderr,pre,post,quiet))
+			stderr_thread = threading.Thread(target=__handle_stream, args=(proc.stderr,task.stderr,pre,post,quiet),daemon=True)
 			stderr_thread.start()
 			# Monitor the subprocess and terminate it after the timeout
 			start_time = time.time()
@@ -163,7 +225,7 @@ def __run_command(task,sem, timeout=60, quiet=False,dry_run=False,with_stdErr=Fa
 			return task.stdout
 
 def run_command(command, timeout=0,max_threads=1,quiet=False,dry_run=False,with_stdErr=False,
-				return_code_only=False,return_object=False):
+				return_code_only=False,return_object=False,wait_for_return=True):
 	'''
 	Run a command
 
@@ -173,47 +235,93 @@ def run_command(command, timeout=0,max_threads=1,quiet=False,dry_run=False,with_
 		max_threads: The maximum number of threads to use
 		quiet: Whether to suppress output
 		dry_run: Whether to simulate running the command
-		with_stdErr: Whether to return the standard error output
+		with_stdErr: Whether to append the standard error output to the standard output
 		return_code_only: Whether to return only the return code
 		return_object: Whether to return the Task object
+		wait_for_return: Whether to wait for the return of the command
 
 	@returns:
 		None | int | list[str] | Task: The output of the command
 	'''
-	return run_commands([command], timeout, max_threads, quiet, dry_run, with_stdErr, return_code_only, return_object)[0]
+	return run_commands(commands=[command], timeout=timeout, max_threads=max_threads, quiet=quiet, 
+					 dry_run=dry_run, with_stdErr=with_stdErr, return_code_only=return_code_only, 
+					 return_object=return_object,parse=False,wait_for_return=wait_for_return)[0]
+
+def __format_command(command,expand = False):
+	'''
+	Format a command
+
+	@params:
+		command: The command to format
+		expand: Whether to expand ranges
+
+	@returns:
+		list[list[str]]: The formatted commands sequence
+	'''
+	if isinstance(command,str):
+		if expand:
+			commands = _expand_ranges(command)
+		else:
+			commands = [command]
+		return [command.split() for command in commands]
+	# elif it is a iterable
+	elif hasattr(command,'__iter__'):
+		sanitized_command = []
+		for field in command:
+			if isinstance(field,str):
+				sanitized_command.append(field)
+			else:
+				sanitized_command.append(repr(field))
+		if not expand:
+			return [sanitized_command]
+		sanitized_expanded_command = [_expand_ranges(field) for field in sanitized_command]
+		# now the command had been expanded to list of list of fields with each field expanded to all possible options
+		# we need to generate all possible combinations of the fields
+		# we will use the cartesian product to do this
+		commands = list(itertools.product(*sanitized_expanded_command))
+		return [list(command) for command in commands]
+	else:
+		return __format_command(str(command),expand=expand)
 
 def run_commands(commands, timeout=0,max_threads=1,quiet=False,dry_run=False,with_stdErr=False,
-				 return_code_only=False,return_object=False):
+				 return_code_only=False,return_object=False, parse = False, wait_for_return = True):
 	'''
 	Run multiple commands in parallel
 
 	@params:
-		commands: A list of commands to run
+		commands: A list of commands to run ( list[str] | list[list[str]] )
 		timeout: The timeout for each command
 		max_threads: The maximum number of threads to use
 		quiet: Whether to suppress output
 		dry_run: Whether to simulate running the commands
-		with_stdErr: Whether to return the standard error output
+		with_stdErr: Whether to append the standard error output to the standard output
 		return_code_only: Whether to return only the return code
 		return_object: Whether to return the Task object
+		parse: Whether to parse ranged input
+		wait_for_return: Whether to wait for the return of the commands
 
 	@returns:
 		list: The output of the commands ( list[None] | list[int] | list[list[str]] | list[Task] )
 	'''
 	# split the commands in commands if it is a string
-	commands = [command.split() if isinstance(command,str) else command for command in commands]
+	formatedCommands = []
+	for command in commands:
+		formatedCommands.extend(__format_command(command,expand=parse))
 	# initialize the tasks
-	tasks = [Task(command) for command in commands]
+	tasks = [Task(command) for command in formatedCommands]
 	# run the tasks with max_threads. if max_threads is 0, use the number of commands
 	if max_threads < 1:
-		max_threads = len(commands)
-	if max_threads > 1:
+		max_threads = len(formatedCommands)
+	if max_threads > 1 or not wait_for_return:
 		sem = threading.Semaphore(max_threads)  # Limit concurrent sessions
-		threads = [threading.Thread(target=__run_command, args=(task,sem,timeout,quiet,dry_run,...)) for task in tasks]
+		threads = [threading.Thread(target=__run_command, args=(task,sem,timeout,quiet,dry_run,...),daemon=True) for task in tasks]
 		for thread in threads:
 			thread.start()
-		for thread in threads:
-			thread.join()
+		if wait_for_return:
+			for thread in threads:
+				thread.join()
+		else:
+			__running_threads.extend(threads)
 	else:
 		# just process the commands sequentially
 		sem = threading.Semaphore(1)
@@ -229,6 +337,20 @@ def run_commands(commands, timeout=0,max_threads=1,quiet=False,dry_run=False,wit
 	else:
 		return [task.stdout for task in tasks]
 
+def join_threads(threads=__running_threads,timeout=None):
+	'''
+	Join threads
+
+	@params:
+		threads: The threads to join
+		timeout: The timeout
+
+	@returns:
+		None
+	'''
+	for thread in threads:
+		thread.join(timeout=timeout)
+
 def input_with_timeout_and_countdown(timeout, prompt='Please enter your selection'):
 	"""
 	Read an input from the user with a timeout and a countdown.
@@ -361,17 +483,16 @@ def print_progress_bar(iteration, total, prefix='', suffix=''):
 		if iteration % 5 == 0:
 			print(_genrate_progress_bar(iteration, total, prefix, suffix))
 
-
 def main():
 	parser = argparse.ArgumentParser(description='Run multiple commands in parallel')
 	parser.add_argument('commands', metavar='command', type=str, nargs='+',help='commands to run')
-#	parser.add_argument('-p','--parse', action='store_true',help='parse ranged input')
+	parser.add_argument('-p','--parse', action='store_true',help='Parse ranged input and expand them into multiple commands')
 	parser.add_argument('-t','--timeout', metavar='timeout', type=int, default=60,help='timeout for each command')
 	parser.add_argument('-m','--max_threads', metavar='max_threads', type=int, default=1,help='maximum number of threads to use')
 	parser.add_argument('-q','--quiet', action='store_true',help='quiet mode')
 	parser.add_argument('-V','--version', action='version', version=f'%(prog)s {version} by pan@zopyr.us')
 	args = parser.parse_args()
-	run_commands(args.commands, args.timeout, args.max_threads, args.quiet)
+	run_commands(args.commands, args.timeout, args.max_threads, args.quiet,parse = args.parse)
 
 if __name__ == '__main__':
 	main()

multiCMD-1.13.dist-info/RECORD

@@ -1,7 +0,0 @@
-multiCMD.py,sha256=_agL0neMTFIiApwMJ-Pg0Sygc267k1qbaGku0ROP34E,12082
-multiCMD-1.13.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-multiCMD-1.13.dist-info/METADATA,sha256=RraYvntxzCblSCs8ccYpsR6ISfnjn71V6ik3XO3ih4M,4772
-multiCMD-1.13.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-multiCMD-1.13.dist-info/entry_points.txt,sha256=nSLBkYrcUCQxt1w3LIJkvgOhpRYEC0xAPqNG7u4OYs8,89
-multiCMD-1.13.dist-info/top_level.txt,sha256=DSqgftD40G09F3qEjpHRCUNUsGUvGZZG69Sm3YEUiWI,9
-multiCMD-1.13.dist-info/RECORD,,