pipemake 0.6__tar.gz

pipemake-0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Kocher Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pipemake-0.6/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: pipemake
+Version: 0.6
+Summary: Pipemake: A pipeline creation tool using Snakemake
+Home-page: https://github.com/kocherlab/pipemake
+License: MIT
+Project-URL: Documentation, https://pipemake.readthedocs.io/en/latest/
+Project-URL: Code, https://github.com/kocherlab/pipemake
+Project-URL: Issue tracker, https://github.com/kocherlab/pipemake/issues
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: snakemake
+
+PipeMake
+========
+
+Snakemake-based pipeline platform

pipemake-0.6/README.rst

@@ -0,0 +1,4 @@
+PipeMake
+========
+
+Snakemake-based pipeline platform

pipemake-0.6/pipemake/__init__.py

@@ -0,0 +1,16 @@
+import sys
+
+# Basic Information
+__name__ = "pipemake"
+__version__ = "0.6"
+__summary__ = "Pipemake: A pipeline creation tool using Snakemake"
+__url__ = "https://github.com/kocherlab/pipemake"
+__code__ = "https://github.com/kocherlab/pipemake"
+__issue__ = "https://github.com/kocherlab/pipemake/issues"
+__docs__ = "https://pipemake.readthedocs.io/en/latest/"
+__license__ = "MIT"
+__copyright__ = "2023"
+
+# Author Information
+__authors__ = "Andrew Webb and Sarah Kocher"
+__email__ = "19213578+aewebb80@users.noreply.github.com"

pipemake-0.6/pipemake/config.py

@@ -0,0 +1,136 @@
+import os
+import copy
+import yaml
+
+from collections import defaultdict
+
+from pipemake.processIO import standardizeInput, returnSamples, returnPaths
+from pipemake.snakemakeIO import SnakePipelineIO
+
+def loadPipelineConfigs (directory):
+
+	# Create dicts to store the relevant yaml data
+	pipeline_config_args = {}
+	pipeline_setup = {}
+	pipeline_cmd_line = {}
+	pipeline_snakefiles = defaultdict(list)
+	
+	# Check the config directory exists
+	config_dir = os.path.join(directory, 'configs')
+	if not os.path.isdir(config_dir): raise Exception(f'Unable to find pipeline directory: {config_dir}')
+
+	# Loop the configs
+	for config_filename in os.listdir(config_dir):
+		config_file = os.path.join(config_dir, config_filename)
+
+		# Confirm the path is a file
+		if not os.path.isfile(config_file): continue
+
+		with open(config_file, "r") as config_stream:
+			try: config_yaml = yaml.safe_load(config_stream)
+			except: raise Exception('Error opening YAML')
+
+			# Check pipeline_names for repeats, and if found report error
+			if config_yaml['pipeline'] in pipeline_config_args:
+				raise Exception(f"Pipeline {config_yaml['pipeline']} has already been assigned. Please check pipeline configs")
+
+			pipeline_config_args[config_yaml['pipeline']] = config_yaml['parser']
+			pipeline_setup[config_yaml['pipeline']] = config_yaml['setup']
+			pipeline_cmd_line[config_yaml['pipeline']] = config_yaml['command-line']
+			pipeline_snakefiles[config_yaml['pipeline']] = config_yaml['snakefiles']
+		
+	return pipeline_config_args, pipeline_setup, pipeline_cmd_line, pipeline_snakefiles
+
+def processPipelineSetup (pipeline_setup, pipeline_args):
+
+	# Create list to store setup args
+	process_dict = {}
+
+	for setup_name, setup_methods in pipeline_setup.items():
+		for method_args in setup_methods.values():
+			
+			# Assign the arg groups
+			input_args = method_args['input']
+			
+			# Check for missing arguments
+			for input_arg in input_args['args']:
+				if input_arg.replace('-', '_') not in pipeline_args: raise Exception(f'Setup argument {input_arg} not found among pipeline argument')
+
+			# Confirm expected args were specified
+			method_missing_args = [_a for _a in input_args['args'] if not pipeline_args[_a.replace('-', '_')]]
+
+			# Skip if missing arguments
+			if method_missing_args: continue
+
+			if 'standardize' in method_args:
+
+				# Create a dict of the standardize args
+				std_args = copy.deepcopy(method_args['standardize'])
+
+				# Update the arguments
+				for std_arg, arg_params in std_args['args'].items():
+					if not isinstance(arg_params, str): continue
+					std_args['args'][std_arg] = arg_params.replace('-', '_').format(**pipeline_args)
+
+				# Standardize the input
+				standardizeInput(**std_args)
+
+				# Assign the method paths
+				method_paths = returnPaths(**std_args)
+
+				# Check for method paths
+				if len(method_paths) > 0: 
+					
+					# Check if the args have already been created
+					if 'singularity-args' not in process_dict:
+						process_dict['singularity-args'] = defaultdict(list)
+
+					# Return any paths that need to be accounted for
+					process_dict['singularity-args']['bind'].extend(method_paths)
+
+			if 'samples' in method_args:
+
+				# Create a dict of the standardize args
+				samples_args = copy.deepcopy(method_args['samples'])
+
+				# Update the arguments
+				for samples_arg, arg_params in samples_args['args'].items():
+					if not isinstance(arg_params, str): continue
+					samples_args['args'][samples_arg] = arg_params.replace('-', '_').format(**pipeline_args)
+
+				# Assign the samples from the method
+				method_samples = returnSamples(**samples_args)
+
+				# Confirm the samples are not already assigned
+				if method_samples and 'samples' in process_dict: raise Exception(f'Samples already assigned')
+
+				# Standardize the input
+				process_dict['samples'] = method_samples
+
+	return process_dict
+
+def processPipelineCmdLine (pipeline_cmd_line, pipeline_args):
+
+	# Create list to store the command line arguments
+	cmd_line_list = ['snakemake']
+
+	# Process the command line
+	for cmd_arg, cmd_value in pipeline_cmd_line.items():
+
+		# Add the basic args
+		if isinstance(cmd_value, bool): cmd_line_list.append(f'--{cmd_arg}')
+		else: cmd_line_list.extend([f'--{cmd_arg}', cmd_value])
+		
+		# Check if using singularity
+		if cmd_arg == 'use-singularity' and cmd_value and 'singularity-args' in pipeline_args:
+
+			# Assign the singularity args
+			singularity_args_list = []
+			for singularity_arg, singularity_value in pipeline_args['singularity-args'].items():
+				singularity_args_list.append(f'--{singularity_arg} ' + ','.join(singularity_value))
+
+			# Add the singularity args
+			singularity_args_str = ','.join(singularity_args_list)
+			cmd_line_list.extend(['--singularity-args', f'"{singularity_args_str}"'])
+
+	return ' '.join(map(str,cmd_line_list))

pipemake-0.6/pipemake/logger.py

@@ -0,0 +1,51 @@
+import logging
+import sys
+
+def startLogger (log_filename = None, filemode = 'w'):
+
+	# Close any old loggers
+	for handler in logging.root.handlers[:]:
+		handler.close()
+		logging.root.removeHandler(handler)
+
+	# Star the logger
+	if log_filename: logging.basicConfig(filename = log_filename, filemode = filemode, level = 'INFO', format = '%(asctime)s - %(levelname)s: %(message)s', datefmt = '%Y-%m-%d %H:%M:%S')
+	else: logging.basicConfig(stream = sys.stdout, level = 'INFO', format = '%(asctime)s - %(levelname)s: %(message)s', datefmt = '%Y-%m-%d %H:%M:%S')
+
+	# Start logging to stdout
+	stdout_log = logging.StreamHandler()
+
+	# Assign the stdout logging level
+	stdout_log.setLevel(logging.WARNING)
+
+	# Define the stdout format
+	console_format = logging.Formatter('%(funcName)s - %(levelname)s: %(message)s')
+
+	# Assign the format
+	stdout_log.setFormatter(console_format)
+
+	# Add the stdout handler
+	logging.getLogger('').addHandler(stdout_log)
+
+	# Update the exception handler to log the exception
+	def expHandler(etype,val,tb):
+
+		# Log the error
+		logging.error("%s" % (val), exc_info=(etype,val,tb))
+
+	# Update the exception hook
+	sys.excepthook = expHandler
+
+def logArgDict (arg_dict, print_undefined = False, omit = []):
+
+	# Loop the arguments
+	for arg, value in arg_dict.items():
+
+		# Skip arg if in omit list
+		if arg in omit: continue
+
+		# Report only defined arguments, unless print_undefined is True
+		if value is None and not print_undefined: continue
+
+		# Log the argument
+		logging.info('Argument %s: %s' % (arg, value))

pipemake-0.6/pipemake/pipemake.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import yaml
+import random
+import string
+import logging
+import argparse
+import datetime
+
+from pydoc import locate
+from collections import defaultdict
+
+from pipemake.logger import *
+from pipemake.config import *
+from pipemake.snakemakeIO import SnakePipelineIO
+
+def jobRandomString (num_chars = 4):
+	global random_string
+
+	# Create a random string, if not done already
+	if not random_string: random_string = ''.join(random.choices(string.digits + string.ascii_uppercase, k = num_chars))
+	
+	return random_string
+
+def jobTimeStamp ():
+	global time_stamp
+
+	# Create a time stamp, if not done already
+	if not time_stamp: time_stamp = datetime.datetime.now().strftime("%Y-%m-%d")
+
+	return time_stamp
+
+def pipeline_parser (config_parser_pipelines):
+
+	# Change default behavior on error
+	class MyParser(argparse.ArgumentParser): 
+		def error(self, message):
+			sys.stderr.write('error: %s\n\n' % message)
+			self.print_help()
+			sys.exit(2)
+
+	# Remove metavar line in parser
+	class SubcommandHelpFormatter(argparse.RawDescriptionHelpFormatter):
+		def _format_action(self, action):
+			parts = super(argparse.RawDescriptionHelpFormatter, self)._format_action(action)
+			if action.nargs == argparse.PARSER: parts = "\n".join(parts.split("\n")[1:])
+			return parts
+
+	def confirmDir ():
+		'''Custom action to confirm directory exists'''
+		class customAction(argparse.Action):
+			def __call__(self, parser, args, value, option_string=None):
+				if not os.path.isdir(value):
+					raise IOError(f'Unable to find directory: {value}')
+				setattr(args, self.dest, value)
+		return customAction
+
+	def confirmFile ():
+		'''Custom action to confirm file exists'''
+		class customAction(argparse.Action):
+			def __call__(self, parser, args, value, option_string=None):
+				if not os.path.isfile(value):
+					raise IOError(f'Unable to find file: {value}')
+				setattr(args, self.dest, value)
+		return customAction
+
+	def createArgGroup (parser, group_args):
+		'''Create the argument group'''
+
+		# Set the groip argument, if not given
+		if 'group' not in group_args: group_args['group'] = {}
+
+		# Set the argument type, if not given
+		if 'type' not in group_args['group']: group_args['group']['type'] = 'argument_group'
+
+		# Set if the group is required, if not given
+		if 'required' not in group_args['group']: group_args['group']['required'] = False
+
+		# Set the group label, if not given
+		if 'label' not in group_args['group']: group_args['group']['label'] = pipeline_arg_group
+			
+		# Create the argument group
+		if group_args['group']['type'] == 'argument_group': 
+			return parser.add_argument_group(f"{pipeline_name} {group_args['group']['label']} arguments")
+
+		# Create the mutually exclusive group
+		elif group_args['group']['type'] == 'mutually_exclusive':
+			arg_group = parser.add_argument_group(f"{pipeline_name} {group_args['group']['label']} arguments")
+			return arg_group.add_mutually_exclusive_group(required = group_args['group']['required'])
+
+		# Report an error if the group type is not supported
+		else: raise Exception(f'Group type not supported: {group_args["type"]}')
+	
+	# Create the pipeline selection parser
+	pipeline_parser = MyParser(formatter_class = SubcommandHelpFormatter)
+	pipeline_parser._positionals.title = "Pipeline selection argument options (positional)"
+		
+	# Create the subparsers
+	pipeline_subparsers = pipeline_parser.add_subparsers(dest = 'pipeline', required = True)
+
+	# Assign the arguments for each pipeline
+	for pipeline_name, pipeline_params in config_parser_pipelines.items():
+
+		# Create the subparser
+		pipeline_subparser = pipeline_subparsers.add_parser(pipeline_name, help = pipeline_params['help'], add_help = False)
+
+		pipeline_arg_groups = {}
+
+		# Add the required argument group
+		pipeline_arg_groups['required'] = pipeline_subparser.add_argument_group(f"{pipeline_name} required arguments")
+
+		# Loop the pipeline groups
+		for pipeline_arg_group in pipeline_params['arg-groups']:
+
+			# Create the argument group, if not the basic subparsers
+			if pipeline_arg_group != 'basic':
+
+				# Check if the group already exists, then raise an exception if it does
+				if pipeline_arg_group in pipeline_arg_groups: raise Exception(f'Cannot create group {pipeline_arg_group}. Group already exists.')
+
+				# Create the argument group
+				pipeline_arg_groups[pipeline_arg_group] = pipeline_subparser.add_argument_group(f"{pipeline_name} {pipeline_arg_group} arguments")
+
+		# Add the optional argument group
+		pipeline_arg_groups['optional'] = pipeline_subparser.add_argument_group(f"{pipeline_name} optional arguments")
+
+		# Loop the pipeline mutually exclusive groups
+		for pipeline_arg_group, group_args in pipeline_params['arg-groups'].items():
+			if 'mutually-exclusive-groups' not in group_args: continue
+
+			# Loop the mutually exclusive groups
+			for me_group_name, me_group_args in group_args['mutually-exclusive-groups'].items():
+
+				# Confirm the mutually exclusive group has not been created
+				if me_group_name in pipeline_arg_groups: raise Exception(f'Cannot create mutually exclusive group {me_group_name}. Group already exists.')
+
+				# Check if the group is required, if not given
+				if 'required' not in me_group_args: me_group_args['required'] = False
+
+				# Create the mutually exclusive group
+				if pipeline_arg_group == 'basic' and me_group_args['required']:
+					pipeline_arg_groups[me_group_name] = pipeline_arg_groups['required'].add_mutually_exclusive_group(required = me_group_args['required'])
+				elif pipeline_arg_group == 'basic': 
+					pipeline_arg_groups[me_group_name] = pipeline_arg_groups['optional'].add_mutually_exclusive_group(required = me_group_args['required'])
+				elif pipeline_arg_group != 'basic' and pipeline_arg_group in pipeline_arg_groups:
+					pipeline_arg_groups[me_group_name] = pipeline_arg_groups['optional'].add_mutually_exclusive_group(required = me_group_args['required'])
+				else: raise Exception(f'Unable to assign mutually exclusive group: {me_group_name}')
+		
+		# Loop the pipeline arguments
+		for pipeline_arg_group, group_args in pipeline_params['arg-groups'].items():
+
+			'''2. Add the arguments to the argument subparser'''
+
+			# Loop the arguments in the group
+			for pipeline_arg_name, arg_args in group_args['args'].items():
+
+				# Set the datatypes
+				if 'type' in arg_args: 
+					try: arg_args['type'] = locate(arg_args['type'])
+					except: raise Exception(f"Unable to locate type: {arg_args['type']}")
+	
+				# Configure the action parameter, if specified
+				if 'action' in arg_args:
+					if arg_args['action'] == 'confirmDir': arg_args['action'] = confirmDir()
+					elif arg_args['action'] == 'confirmFile': arg_args['action'] = confirmFile()
+
+				# Configure the default params, if specified
+				if 'default' in arg_args and isinstance(arg_args['default'], dict):
+					default_str = arg_args['default']['str']
+					if 'suffix' in arg_args['default']:
+						if isinstance(arg_args['default']['suffix'], str): arg_args['default']['suffix'] = [arg_args['default']['suffix']]
+						for suffix in arg_args['default']['suffix']:
+
+							# Add underscores if needed
+							if default_str: default_str += '_'
+
+							# Process suffix strings
+							if isinstance(suffix, str): default_str += suffix
+
+							# Process suffix dicts
+							elif isinstance(suffix, dict):
+
+								# Convert the suffix dict to lowercase keys
+								suffix_dict =  {_k.lower():_v for _k, _v in suffix.items()}
+
+								if 'function' not in suffix_dict: raise Exception(f"Suffix dict not supported: {suffix_dict}")
+
+								if suffix['function'] == 'jobTimeStamp':  default_str += jobTimeStamp()
+								elif suffix['function'] == 'jobRandomString':  default_str += jobRandomString()
+								else: raise Exception(f"Function not supported: {suffix['function']}")
+							
+					arg_args['default'] = default_str
+
+				# Assign the argument to a mutually exclusive group, if applicable
+				if 'mutually-exclusive' in arg_args:
+					me_group = arg_args['mutually-exclusive']
+					del arg_args['mutually-exclusive']
+					pipeline_arg_groups[me_group].add_argument(f'--{pipeline_arg_name}', **arg_args)
+
+				# Assign the argument to it respective group, if applicable
+				elif pipeline_arg_group != 'basic' and pipeline_arg_group in pipeline_arg_groups: 
+					pipeline_arg_groups[pipeline_arg_group].add_argument(f'--{pipeline_arg_name}', **arg_args)
+
+				# Assign the argument to the required group, if basic and required
+				elif pipeline_arg_group == 'basic' and 'required' in arg_args: 
+					pipeline_arg_groups['required'].add_argument(f'--{pipeline_arg_name}', **arg_args)
+
+				# Assign the argument to the optional group, if basic and not required
+				elif pipeline_arg_group == 'basic': 
+					pipeline_arg_groups['optional'].add_argument(f'--{pipeline_arg_name}', **arg_args)
+				
+				# Report an error if the group is not supported
+				else:
+					raise Exception(f'Argument group not supported: {pipeline_arg_group}')
+				
+		# Add the common optional arguments, but at the end of the list
+		pipeline_arg_groups['optional'].add_argument('--scale-threads', help = 'Scale the threads for each task', type = float, default = 1.0)
+		pipeline_arg_groups['optional'].add_argument('--scale-mem', help = 'Scale the memory (RAM) for each task', type = float, default = 1.0)
+		pipeline_arg_groups['optional'].add_argument('--resource-yml', help = 'Create a seperate resource yaml', action = 'store_true')
+		pipeline_arg_groups['optional'].add_argument('--singularity-dir', help = 'Assign different directory of singularity images', type = str, default = '/Genomics/argo/users/aewebb/.local/images/')
+		pipeline_arg_groups['optional'].add_argument('-h', '--help', action = 'help', help = 'show this help message and exit')
+
+	return vars(pipeline_parser.parse_args())
+
+# Create variables to store randomString and timeStamp
+random_string = None
+time_stamp = None
+
+def main():
+
+	# Assign the pipeline directory
+	if os.environ.get('KPDIR'): pipeline_storage_dir = os.environ.get('KPDIR')
+	else: pipeline_storage_dir = 'pipelines'
+
+	# Confirm the pipeline directory exists
+	if not os.path.isdir(pipeline_storage_dir): raise Exception(f'Unable to find pipeline directory: {pipeline_storage_dir}')
+
+	# Loads the configs
+	pipeline_config_args, pipeline_setup, pipeline_cmd_line, pipeline_snakefiles = loadPipelineConfigs(pipeline_storage_dir)
+
+	# Parse the aguments from the configs
+	pipeline_args = pipeline_parser(pipeline_config_args)
+
+	# Update the pipeline args with the pipeline directory
+	pipeline_args['pipeline_storage_dir'] = pipeline_storage_dir
+
+	# Check that a pipeline was assigned
+	if not pipeline_args['pipeline']: raise Exception(f'No pipeline specified')
+
+	# Create the working directory
+	if not os.path.exists(pipeline_args['work_dir']): os.makedirs(pipeline_args['work_dir'])
+
+	# Create the pipeline job directory
+	pipeline_args['pipeline_job_dir'] = os.path.join(pipeline_args['work_dir'], f'.pipeline')
+	if not os.path.exists(pipeline_args['pipeline_job_dir']): os.makedirs(pipeline_args['pipeline_job_dir'])
+
+	# Start logger and log the arguments
+	startLogger(os.path.join(pipeline_args['pipeline_job_dir'], f'pipeline.log'))
+	logArgDict(pipeline_args, omit = ['pipeline_job_dir'])
+
+	# Process the pipeline setup
+	setup_arg_dict = processPipelineSetup(pipeline_setup[pipeline_args['pipeline']], pipeline_args)
+
+	# Update the pipeline args if the setup created new args
+	if setup_arg_dict: pipeline_args.update(setup_arg_dict)
+
+	# Create the snakemake pipeline
+	snakemake_pipeline = SnakePipelineIO.open(**pipeline_args)
+
+	# Add the snakemake modules to the pipeline
+	for smkm_filename in pipeline_snakefiles[pipeline_args['pipeline']]:
+		snakemake_pipeline.addModule(smkm_filename)
+
+	# Create the snakemake config file
+	snakemake_pipeline.writeConfig(pipeline_args)
+
+	# Create the snakemake piepline file
+	snakemake_pipeline.writePipeline()
+
+	# Close the snakemake pipeline
+	snakemake_pipeline.close()
+
+	# Create the command line
+	print(processPipelineCmdLine(pipeline_cmd_line[pipeline_args['pipeline']], pipeline_args))
+
+if __name__ == '__main__':
+	main()

pipemake-0.6/pipemake/processIO.py

@@ -0,0 +1,66 @@
+from pipemake.seqIO import SeqFileIO, SeqTableIO
+from pipemake.wildcardIO import WildcardIO
+
+class ProcessIO ():
+	def __init__ (self, processIO, standardize_func = None, **kwargs):
+		self.processIO = processIO
+		self.standardize_call = getattr(self.processIO, standardize_func)
+		self.samples = []
+
+	@classmethod
+	def fromWildcardStr (cls, wildcard_str = '', **kwargs):
+		return cls(WildcardIO.fromStr(wildcard_str, **kwargs), standardize_func = 'standardizedFiles')
+
+	@classmethod
+	def fromTableFile (cls, table_filename = '', **kwargs):
+		return cls(SeqTableIO.fromFilenameStr(table_filename, **kwargs), standardize_func = 'standardizedFiles')
+
+	@classmethod
+	def fromFileStr (cls, input_filename = '', **kwargs):
+		return cls(SeqFileIO.create(input_filename, **kwargs), standardize_func = 'standardize')
+
+	def standardize (self, standardized_filename = '', **kwargs):
+		self.standardize_call(standardized_filename, **kwargs)
+
+	def returnSamples (self, **kwargs):
+		return self.processIO.returnSamples()
+
+	def returnPaths (self, **kwargs):
+		return self.processIO.returnPaths(**kwargs)
+
+
+def standardizeInput (method = '', args = {}):
+	
+	# Create the standardization call
+	if method == 'wildcard-str': standardize_input_call = ProcessIO.fromWildcardStr(**args)
+	elif method == 'table-file': standardize_input_call = ProcessIO.fromTableFile(**args)
+	elif method == 'file-str': standardize_input_call = ProcessIO.fromFileStr(**args)
+	else: raise Exception(f'No standardization method given for: {method}')
+	
+	# Standardize the input
+	standardize_input_call.standardize(**args)
+
+def returnPaths (method = '', args = {}):
+
+	# Create the standardization call
+	if method == 'wildcard-str': return_path_call = ProcessIO.fromWildcardStr(**args)
+	elif method == 'table-file': return_path_call = ProcessIO.fromTableFile(**args)
+	elif method == 'file-str': return_path_call = ProcessIO.fromFileStr(**args)
+	else: raise Exception(f'No standardization method given for: {method}')
+	
+	return return_path_call.returnPaths(**args)
+
+def returnSamples (method = '', args = {}):
+
+	# Create the return samples call
+	if method == 'wildcard-str': return_samples_call = ProcessIO.fromWildcardStr(**args)
+	elif method == 'table-file': return_samples_call = ProcessIO.fromTableFile(**args)
+	elif method == 'file-str': raise Exception('Not implemented')
+	else: raise Exception(f'No standardization method given for: {method}')
+	
+	return return_samples_call.returnSamples()
+
+
+	
+
+