def main(): # create a parser object for getting the command line options parser = my_argparse.MyArgumentParser() # mandatory arguments parser.add_argument('-u', '--user', dest='user', required=True, type=str) parser.add_argument(dest='input_file') # optional arguments parser.add_argument('-ser', '--server', dest='server', required=False, default='https://' + os_utils.getenv_required('XNAT_PBS_JOBS_XNAT_SERVER'), type=str) parser.add_argument('-p', '--password', dest='password', required=False, type=str) # parse the command line arguments args = parser.parse_args() if args.password: password = args.password else: password = getpass.getpass("Password: "******"Parsed arguments:") _inform(" Username: "******" Password: "******"*** password mask ***") _inform(" Server: " + args.server) _inform(" Input File: " + args.input_file) _inform("") input_file = open(args.input_file, 'r') for line in input_file: line = str_utils.remove_ending_new_lines(line) line = line.strip() if line != '' and line[0] != '#': (project, subject, session, resource) = line.split('\t') _inform("") _inform(" Project: " + project) _inform(" Subject: " + subject) _inform(" Session: " + session) _inform(" Resource: " + resource) _inform("") delete_resource.delete_resource(args.user, password, args.server, project, subject, session, resource)
def main(): parser = my_argparse.MyArgumentParser() parser.add_argument('-d', '--directory', dest='directory', required=True, type=str) args = parser.parse_args() root_path = os.path.expandvars(os.path.expanduser(args.directory)) print("root_path: " + root_path) os_utils.replace_symlinks_with_relative(root_path)
def main(): # create a parser object for getting the command line arguments parser = my_argparse.MyArgumentParser( description="Program to delete all DB resources of a given name for all sessions in a given ConnectomeDB project.") # mandatory arguments parser.add_argument('-u', '--user', dest='user', required=True, type=str) parser.add_argument('-pw', '--password', dest='password', required=True, type=str) parser.add_argument('-pr', '--project', dest='project', required=True, type=str) parser.add_argument('-r', '--resource', dest='resource', required=True, type=str) # optional arguments parser.add_argument('-ser', '--server', dest='server', required=False, default='https://' + os_utils.getenv_required('XNAT_PBS_JOBS_XNAT_SERVER'), type=str) parser.add_argument('-f', '--force', dest='force', action='store_true', required=False, default=False) # parse the command line arguments args = parser.parse_args() # show parsed arguments _inform("Parsed arguments:") _inform(" Username: "******" Password: "******"*** password mask ***") _inform(" Server: " + args.server) _inform(" Project: " + args.project) _inform(" Resource: " + args.resource) _inform(" Force: " + str(args.force)) # find all instances of the specified resource in the specified project my_xnat_archive = xnat_archive.XNAT_Archive() archive_root = my_xnat_archive.project_archive_root(args.project) dir_list = glob.glob(archive_root + os.sep + '*') for directory in sorted(dir_list): resource_dir_to_look_for = directory + os.sep + 'RESOURCES' + os.sep + args.resource if os.path.isdir(resource_dir_to_look_for): unprefixed = resource_dir_to_look_for.replace(archive_root + os.sep, "") sep_loc = unprefixed.find(os.sep) session = unprefixed[:sep_loc] underscore_loc = session.find('_') subject = session[:underscore_loc] _inform("Deleting resource: " + args.resource + " for session: " + session) delete_resource.delete_resource(args.user, args.password, args.server, args.project, subject, session, args.resource, args.force)
def main(): parser = my_argparse.MyArgumentParser() parser.add_argument("full_path") parser.add_argument("-v", "--verbose", dest="verbose", action='store_true', required=False, default=False) args = parser.parse_args() file_utils.make_all_links_into_copies(args.full_path, verbose=args.verbose)
def main(): # create a parser object for getting the command line options parser = my_argparse.MyArgumentParser(description="Program to check Diffusion Preprocessing Output size") # mandatory arguments parser.add_argument('-p', '--project', dest='project', required=True, type=str) # optional arguments parser.add_argument('-s', '--subject', dest='subject', required=False, default='all', type=str) # parse the command line arguments args = parser.parse_args() # show parsed arguments log.debug("Project: " + args.project) log.debug("Subject: " + args.subject) # create archive archive = hcp3t_archive.Hcp3T_Archive() # Create a list of subjects to process subject_list = _build_subject_list(archive, args.project, args.subject) all_succeeded = True # Create a DiffusionOutputSizeChecker size_checker = DiffusionOutputSizeChecker() print("Subject\tExpected Volumes\tCheck Success") for subject in subject_list: subject_info = hcp3t_subject.Hcp3TSubjectInfo(args.project, subject) try: # check the diffusion preprocessing size for the specified subject (success, expected_size, msg) = size_checker.check_diffusion_preproc_size(archive, subject_info) print(subject_info.subject_id + "\t" + str(expected_size) + "\t" + str(success) + "\t" + msg) all_succeeded = all_succeeded and success except NoDiffusionPreprocResource as e: print(subject_info.subject_id + "\t" + "N/A" + "\t" + "N/A" + "\t" + "No Diff Preproc Resource") all_succeeded = False except FileNotFoundError as e: print(subject_info.subject_id + "\t" + "N/A" + "\t" + "N/A" + "\t" + "A necessary output file was not found") all_succeeded = False return all_succeeded
def main(): parser = my_argparse.MyArgumentParser( description="Get meta data about a file from a corresponding JSON file" ) # required arguments parser.add_argument('-f', '--file', dest='file', required=True, type=str) parser.add_argument('-k', '--key', dest='key', required=True, type=str) args = parser.parse_args() meta_data_json_file_name = file_utils.get_meta_data_json_file_name( args.file) meta_data_json_file = open(meta_data_json_file_name, "r") meta_data = json.load(meta_data_json_file) meta_data_json_file.close() value = meta_data[args.key] print(str(value))
def main(): parser = my_argparse.MyArgumentParser( description= "Simple program to delete duplicate lines in a text file. Unlike the Linux/Unix uniq utility, it doesn't require duplicates to be adjacent." ) # optional arguments parser.add_argument('-i', '--input-file', dest='input_file_name', required=False, default=None, type=str) parser.add_argument('-o', '--output-file', dest='output_file_name', required=False, default=None, type=str) # parse the command line arguments args = parser.parse_args() if not args.input_file_name: args.input_file_name = input("Input file name: ") if not args.output_file_name: args.output_file_name = input("Output file name: ") _inform(" Input file name: " + args.input_file_name) _inform("Output file name: " + args.output_file_name) output_lines = [] with open(args.input_file_name, 'r') as input_file: for line in input_file: line = line.rstrip() if line not in output_lines: output_lines.append(line) with open(args.output_file_name, 'w') as output_file: for line in output_lines: output_file.write(line + os.linesep)
def main(): parser = my_argparse.MyArgumentParser() # optional arguments parser.add_argument('-d', '--directory', dest='directory', required=False, default=None, type=str) # parse the command line arguments args = parser.parse_args() if not args.directory: args.directory = input("Directory: ") root_path = os.path.expandvars(os.path.expanduser(args.directory)) print("root_path: " + root_path) os_utils.replace_lndir_symlinks(root_path)
def main(): # create a parser object for getting the command line arguments parser = my_argparse.MyArgumentParser() parser.add_argument('-a', '--all-subjects=', dest='all_subjects', required=True, type=str) parser.add_argument('-t', '--todo-subjects=', dest='todo_subjects', required=True, type=str) args = parser.parse_args() # print("Retrieving all subjects from: " + args.all_subjects) all_subjects_list = hcp7t_subject.read_subject_info_list(args.all_subjects, separator=":") # print("Retrieving subject ids in TODO list from: " + args.todo_subjects) to_do_subjects_list = [] to_do_ids_file = open(args.todo_subjects, "r") for line in to_do_ids_file: subject_id = line[:-1] for subject in all_subjects_list: if subject_id == subject.subject_id: print(str(subject)) break
def main(): # create a parser object for getting the command line options parser = my_argparse.MyArgumentParser( description="Program to delete a DB resource.") # mandatory arguments parser.add_argument('-u', '--user', dest='user', required=True, type=str) parser.add_argument('-pr', '--project', dest='project', required=True, type=str) parser.add_argument('-sub', '--subject', dest='subject', required=True, type=str) parser.add_argument('-ses', '--session', dest='session', required=True, type=str) parser.add_argument('-r', '--resource', dest='resource', required=True, type=str) # optional arguments parser.add_argument('-ser', '--server', dest='server', required=False, default='https://' + os_utils.getenv_required('XNAT_PBS_JOBS_XNAT_SERVER'), type=str) parser.add_argument('-f', '--force', dest='force', action="store_true", required=False, default=False) parser.add_argument('-pw', '--password', dest='password', required=False, type=str) # parse the command line arguments args = parser.parse_args() if args.password: password = args.password else: password = getpass.getpass("Password: "******"Parsed arguments:") _inform(" Username: "******" Password: "******"*** password mask ***") _inform(" Server: " + args.server) _inform(" Project: " + args.project) _inform(" Subject: " + args.subject) _inform(" Session: " + args.session) _inform(" Resource: " + args.resource) _inform(" Force: " + str(args.force)) if args.force: delete_it = True elif user_utils.should_proceed(): delete_it = True else: delete_it = False delete_resource(args.user, password, args.server, args.project, args.subject, args.session, args.resource, delete_it)
config.read(config_file_name) # process the subjects in the list batch_submitter = BatchSubmitter() batch_submitter.submit_jobs(userid, password, subject_list, config, force_job_submissions) if __name__ == '__main__': logging.config.fileConfig( file_utils.get_logging_config_file_name(__file__), disable_existing_loggers=False) parser = my_argparse.MyArgumentParser( description= "Batch mode submission of processing jobs for Structural Preprocessing" ) # option arguments # # The --force-job-submission or -f option tells this program to ignore # checking to see whether a set of jobs is already submitted for a # subject/session and to go ahead and submit the jobs anyhow. parser.add_argument('-f', '--force-job-submission', dest='force_job_submission', action='store_true', required=False, default=False) # parse the command line arguments
complete, queued_or_running): scan_line = "\t".join([ project, subject_id, classifier, scan, str(prereqs_met), resource, str(exists), resource_date_str, str(complete), str(queued_or_running) ]) print(scan_line) output_file.write(scan_line + os.linesep) if __name__ == "__main__": parser = my_argparse.MyArgumentParser( description= "Batch mode checking of completion of Functional Preprocessing") # optional arguments # The --bypass-mark option tells this program to ignore whether the resource # is marked complete and just go ahead and do a full completion check. parser.add_argument('-b', '--bypass-mark', dest='bypass_mark', action='store_true', required=False, default=False) parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',
def _write_subject_info(output_file, project, subject_id, scan, resource_exists, resource_date, files_exist): subject_line = "\t".join([ project, subject_id, scan, str(resource_exists), resource_date, str(files_exist) ]) print(subject_line) output_file.write(subject_line + os.linesep) if __name__ == "__main__": parser = my_argparse.MyArgumentParser() parser.add_argument('-r', '--reg-name', dest='reg_name', required=False, default="", type=str) args = parser.parse_args() if args.reg_name != "": print("reg_name: " + args.reg_name) # get list of subjects to check subject_file_name = 'subjectfiles' + os.sep + file_utils.get_subjects_file_name( __file__)
def PIPELINE_NAME(self): return 'MultiRunIcaFixProcessing' def my_resource(self, archive, subject_info): return archive.multirun_icafix_dir_full_path(subject_info) def my_prerequisite_dir_full_paths(self, archive, subject_info): dirs = [] dirs.append(archive.structural_preproc_dir_full_path(subject_info)) return dirs if __name__ == "__main__": parser = my_argparse.MyArgumentParser( description= "Program to check for completion of MultiRunICAFIX Processing.") # mandatory arguments parser.add_argument('-p', '--project', dest='project', required=True, type=str) parser.add_argument('-s', '--subject', dest='subject', required=True, type=str) parser.add_argument('-c', '--classifier',
output_file.write(header_line + os.linesep) def _write_subject_info(output_file, project, subject_id, prereqs_met, resource, exists, resource_date_str, complete, queued_or_running): subject_line = "\t".join([project, subject_id, str(prereqs_met), resource, str(exists), resource_date_str, str(complete), str(queued_or_running)]) print(subject_line) output_file.write(subject_line + os.linesep) if __name__ == "__main__": parser = my_argparse.MyArgumentParser( description="Batch mode checking of completion of MultiRunIcaFixHCP7T Processing") # optional # The --bypass-mark option tells this program to ignore whether the resource # is marked complete and just go ahead and do a full completion check. parser.add_argument('-b', '--bypass-mark', dest='bypass_mark', action='store_true', required=False, default=False) parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', required=False, default=False) # parse the command line arguments args = parser.parse_args() if args.bypass_mark: module_logger.info("Bypassing completion markers and doing complete check") print("Bypassing completion markers and doing complete check")
count_of_t2w_resources = 0 for name in struct_unproc_dir_names: if name.startswith('T1w'): count_of_t1w_resources += 1 if name.startswith('T2w'): count_of_t2w_resources += 1 # does at least 1 T1w unprocessed resource exist and # at least 1 T2w unprocessed resource exist return (count_of_t1w_resources > 0) and (count_of_t2w_resources > 0) if __name__ == "__main__": parser = my_argparse.MyArgumentParser( description= "Program to check prerequisites for the Structural Preprocessing.") # mandatory arguments parser.add_argument('-p', '--project', dest='project', required=True, type=str) parser.add_argument('-s', '--subject', dest='subject', required=True, type=str) parser.add_argument('-c', '--classifier', dest='classifier',
def main(): # create a parser object for getting the command line arguments parser = my_argparse.MyArgumentParser() # mandatory arguments parser.add_argument('-p', '--project', dest='project', required=True, type=str) parser.add_argument('-s', '--subject', dest='subject', required=True, type=str) parser.add_argument('-d', '--study-dir', dest='output_study_dir', required=True, type=str) # optional arguments parser.add_argument('-c', '--copy', dest='copy', action='store_true', required=False, default=False) phase_choices = [ "FULL", "full", "DIFFUSION_PREPROC_VETTING", "diffusion_preproc_vetting", "STRUCT_PREPROC", "struct_preproc", "DIFFUSION_PREPROC", "diffusion_preproc", "DIFFUSION_BEDPOSTX", "diffusion_bedpostx", "APPLY_HAND_RECLASSIFICATION_PREREQS", "apply_hand_reclassification_prereqs", "REAPPLYFIX_PREREQS", "reapplyfix_prereqs" ] default_phase_choice = phase_choices[0] parser.add_argument('-ph', '--phase', dest='phase', required=False, choices=phase_choices, default=default_phase_choice) # parse the command line arguments args = parser.parse_args() # show arguments module_logger.info("Arguments:") module_logger.info(" Project: " + args.project) module_logger.info(" Subject: " + args.subject) module_logger.info(" Output Study Dir: " + args.output_study_dir) module_logger.info(" Copy: " + str(args.copy)) module_logger.info(" Phase: " + args.phase) subject_info = hcp3t_subject.Hcp3TSubjectInfo(args.project, args.subject) archive = hcp3t_archive.Hcp3T_Archive() # create and configure CinabStyleDataRetriever data_retriever = CinabStyleDataRetriever(archive) data_retriever.copy = args.copy data_retriever.show_log = True # retrieve data based on phase requested if (args.phase.upper() == "FULL"): module_logger.debug("phase = FULL") data_retriever.get_full_data(subject_info, args.output_study_dir) elif (args.phase.upper() == "DIFFUSION_PREPROC_VETTING"): data_retriever.get_diffusion_preproc_vetting_data( subject_info, args.output_study_dir) elif (args.phase.upper() == "STRUCT_PREPROC"): data_retriever.get_data_through_STRUCT_PREPROC(subject_info, args.output_study_dir) elif (args.phase.upper() == "DIFFUSION_PREPROC"): data_retriever.get_data_through_DIFFUSION_PREPROC( subject_info, args.output_study_dir) elif (args.phase.upper() == "DIFFUSION_BEDPOSTX"): data_retriever.get_diffusion_bedpostx_data(subject_info, args.output_study_dir) elif (args.phase.upper() == "APPLY_HAND_RECLASSIFICATION_PREREQS"): data_retriever.get_apply_hand_reclassification_prereqs( subject_info, args.output_study_dir) elif (args.phase.upper() == "REAPPLYFIX_PREREQS"): data_retriever.get_reapplyfix_prereqs(subject_info, args.output_study_dir) data_retriever.remove_symlinks(args.output_study_dir)
def main(): # create a parser object for getting the command line arguments parser = my_argparse.MyArgumentParser() # mandatory arguments parser.add_argument('-p', '--project', dest='project', required=True, type=str) parser.add_argument('-s', '--subject', dest='subject', required=True, type=str) parser.add_argument('-d', '--study-dir', dest='output_study_dir', required=True, type=str) # optional arguments parser.add_argument('-a', '--scan', dest='scan', required=False, type=str, default=None) parser.add_argument('-c', '--copy', dest='copy', action='store_true', required=False, default=False) parser.add_argument('-l', '--log', dest='log', action='store_true', required=False, default=False) parser.add_argument('-r', '--remove-non-subdirs', dest='remove_non_subdirs', action='store_true', required=False, default=False) phase_choices = [ "STRUCT_PREPROC_PREREQS", "struct_preproc_prereqs", "STRUCT_PREPROC_HAND_EDIT_PREREQS", "struct_preproc_hand_edit_prereqs", "DIFF_PREPROC_PREREQS", "diff_preproc_prereqs", "FUNC_PREPROC_PREREQS", "func_preproc_prereqs", "MULTIRUNICAFIX_PREREQS", "multirunicafix_prereqs", "MSMALL_PREREQS", "msmall_prereqs", "DEDRIFTANDRESAMPLE_PREREQS", "dedriftandresample_prereqs", "REAPPLYFIX_PREREQS", "reapplyfix_prereqs" ] default_phase_choice = phase_choices[0] parser.add_argument('-ph', '--phase', dest='phase', required=False, choices=phase_choices, default=default_phase_choice) parser.add_argument('-cl', '--classifier', dest='session_classifier', required=False, type=str, default='3T') # parse the command line arguments args = parser.parse_args() # convert phase argument to uppercase args.phase = args.phase.upper() # show arguments module_logger.info("Arguments:") module_logger.info(" Project: " + args.project) module_logger.info(" Subject: " + args.subject) module_logger.info(" Session Classifier: " + args.session_classifier) module_logger.info(" Output Dir: " + args.output_study_dir) module_logger.info(" Phase: " + args.phase) if args.copy: module_logger.info(" Copy: " + str(args.copy)) if args.log: module_logger.info(" Log: " + str(args.log)) if args.remove_non_subdirs: module_logger.info(" Remove Non-Subdirs: " + str(args.remove_non_subdirs)) subject_info = ccf_subject.SubjectInfo(args.project, args.subject, args.session_classifier, args.scan) archive = ccf_archive.CcfArchive() data_retriever = DataRetriever(archive) data_retriever.copy = args.copy data_retriever.show_log = args.log # retrieve data based on phase requested if args.phase == "STRUCT_PREPROC_PREREQS": data_retriever.get_struct_preproc_prereqs(subject_info, args.output_study_dir) elif args.phase == "STRUCT_PREPROC_HAND_EDIT_PREREQS": data_retriever.get_struct_preproc_hand_edit_prereqs( subject_info, args.output_study_dir) elif args.phase == "DIFF_PREPROC_PREREQS": data_retriever.get_diffusion_preproc_prereqs(subject_info, args.output_study_dir) elif args.phase == "FUNC_PREPROC_PREREQS": data_retriever.get_functional_preproc_prereqs(subject_info, args.output_study_dir) elif args.phase == "MULTIRUNICAFIX_PREREQS": data_retriever.get_multirunicafix_prereqs(subject_info, args.output_study_dir) elif args.phase == "MSMALL_PREREQS": data_retriever.get_msmall_prereqs(subject_info, args.output_study_dir) elif args.phase == "DEDRIFTANDRESAMPLE_PREREQS": data_retriever.get_dedriftandresample_prereqs(subject_info, args.output_study_dir) # Get the group average drift data # As of February 2017, the group average drift data has been moved from HCP_Staging to # HCP_1200 data_retriever.get_msm_group_average_drift_data( "HCP_1200", args.output_study_dir) elif args.phase == "REAPPLYFIX_PREREQS": data_retriever.get_reapplyfix_prereqs(subject_info, args.output_study_dir) if args.remove_non_subdirs: # remove any non-subdirectory data at the output study directory level data_retriever.remove_non_subdirs(args.output_study_dir)
# process subjects in the list batch_submitter = BatchSubmitter() batch_submitter.submit_jobs(userid, password, subject_list, config, force_submission) if __name__ == '__main__': logging_config_file_name = file_utils.get_logging_config_file_name( __file__) print("Reading logging configuration from file: " + logging_config_file_name) logging.config.fileConfig(logging_config_file_name, disable_existing_loggers=False) parser = my_argparse.MyArgumentParser( description="Submit a batch of HCP 7T MultiRunIcaFix Jobs") # option arguments # The -f or --force option tells this program to ignore the fact that a job may # already be running for a specified subject/scan and submit jobs anyhow. # Keep in mind that this will very likely royally screw up the mechanism for # keeping track of whether jobs are queued or running for that subject/scan. # But sometimes, particularly during testing, it is useful and necessary. parser.add_argument('-f', '--force', dest='force', action='store_true', required=False, default=False) # parse the command line arguments
@property def PIPELINE_NAME(self): return 'MsmAllProcessing' def my_resource(self, archive, subject_info): return archive.msm_all_dir_full_path(subject_info) def my_prerequisite_dir_full_paths(self, archive, subject_info): dirs = [] dirs.append(archive.structural_preproc_dir_full_path(subject_info)) return dirs if __name__ == "__main__": parser = my_argparse.MyArgumentParser( description="Program to check for completion of MSM-All Processing.") # mandatory arguments parser.add_argument('-p', '--project', dest='project', required=True, type=str) parser.add_argument('-s', '--subject', dest='subject', required=True, type=str) parser.add_argument('-c', '--classifier', dest='classifier',
output_file.write(header_line + os.linesep) def _write_subject_info(output_file, project, subject_id, classifier, prereqs_met, resource, exists, resource_date_str, complete, queued_or_running): subject_line = "\t".join([project, subject_id, classifier, str(prereqs_met), resource, str(exists), resource_date_str, str(complete), str(queued_or_running)]) print(subject_line) output_file.write(subject_line + os.linesep) if __name__ == "__main__": parser = my_argparse.MyArgumentParser( description="Batch mode checking of completion of MSM-All Processing") # optional arguments # The --bypass-mark option tells this program to ignore whether the resource # is marked complete and just go ahead and do a full completion check. parser.add_argument('-b', '--bypass-mark', dest='bypass_mark', action='store_true', required=False, default=False) parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', required=False, default=False) # parse the command line arguments args = parser.parse_args() if args.bypass_mark: module_logger.info("Bypassing completion markers and doing complete check") print("Bypassing completion markers and doing complete check")
def main(): # create a parser object for getting the command line arguments parser = my_argparse.MyArgumentParser() # mandatory arguments parser.add_argument('-p', '--project', dest='project', required=True, type=str) parser.add_argument('-s', '--subject', dest='subject', required=True, type=str) parser.add_argument('-d', '--study-dir', dest='output_study_dir', required=True, type=str) parser.add_argument('-t', '--structural-reference-project', dest='structural_reference_project', required=True, type=str) # optional arguments parser.add_argument('-c', '--copy', dest='copy', action='store_true', required=False, default=False) parser.add_argument('-l', '--log', dest='log', action='store_true', required=False, default=False) parser.add_argument('-r', '--remove-non-subdirs', dest='remove_non_subdirs', action='store_true', required=False, default=False) parser.add_argument('-j', '--remove-job-and-catalog-files', dest='remove_job_and_catalog_files', action='store_true', required=False, default=False) phase_choices = [ "FULL", "full", "DIFFUSION_PREPROC_VETTING", "diffusion_preproc_vetting", "MULTIRUNICAFIX_PREREQS", "multirunicafix_prereqs", "ICAFIX", "icafix", "MULTIRUNICAFIX", "multirunicafix", "POSTFIX", "postfix" ] parser.add_argument('-ph', '--phase', dest='phase', required=False, choices=phase_choices, default="full") # parse the command line arguments args = parser.parse_args() # show arguments log.info("Arguments:") log.info(" Project: " + args.project) log.info(" Structural Ref Project: " + args.structural_reference_project) log.info(" Subject: " + args.subject) log.info(" Output Study Dir: " + args.output_study_dir) log.info(" Copy: " + str(args.copy)) log.info(" Phase: " + args.phase) log.info(" Log: " + str(args.log)) log.info(" Remove Non-Subdirs: " + str(args.remove_non_subdirs)) subject_info = hcp7t_subject.Hcp7TSubjectInfo( project=args.project, structural_reference_project=args.structural_reference_project, subject_id=args.subject) archive = hcp7t_archive.Hcp7T_Archive() reference_archive = hcp3t_archive.Hcp3T_Archive() # create and configure CinabStyleDataRetriever data_retriever = CinabStyleDataRetriever(archive, reference_archive) data_retriever.copy = args.copy data_retriever.show_log = args.log # retrieve data based on phase requested args.phase = args.phase.upper() if args.phase == "FULL": data_retriever.get_full_data(subject_info, args.output_study_dir) elif args.phase == "DIFFUSION_PREPROC_VETTING": data_retriever.get_diffusion_preproc_vetting_data( subject_info, args.output_study_dir) elif args.phase == "MULTIRUNICAFIX_PREREQS": data_retriever.get_multirunicafix_prereqs(subject_info, args.output_study_dir) elif args.phase == "ICAFIX": data_retriever.get_data_through_ICAFIX(subject_info, args.output_study_dir) elif args.phase == "MULTIRUNICAFIX": data_retriever.get_data_through_multirun_ICAFIX( subject_info, args.output_study_dir) elif args.phase == "POSTFIX": data_retriever.get_data_through_PostFix(subject_info, args.output_study_dir) if args.remove_non_subdirs: # remove any non-subdirectory data at the output study directory level data_retriever.remove_non_subdirs(args.output_study_dir) data_retriever.remove_non_subdirs(args.output_study_dir + os.sep + subject_info.subject_id) if args.remove_job_and_catalog_files: # remove any PBS job files and XNAT catalog files data_retriever.remove_pbs_job_files(args.output_study_dir) data_retriever.remove_xnat_catalog_files(args.output_study_dir)
@property def PIPELINE_NAME(self): return 'StructuralPreprocessing' def my_resource(self, archive, subject_info): return archive.structural_preproc_dir_full_path(subject_info) def my_prerequisite_dir_full_paths(self, archive, subject_info): return archive.available_structural_unproc_dir_full_paths(subject_info) if __name__ == "__main__": parser = my_argparse.MyArgumentParser( description= "Program to check for completion of Structural Preprocessing.") # mandatory arguments parser.add_argument('-p', '--project', dest='project', required=True, type=str) parser.add_argument('-s', '--subject', dest='subject', required=True, type=str) parser.add_argument('-c', '--classifier',
class OneSubjectCompletionChecker(one_subject_completion_checker.OneSubjectCompletionChecker): """Used for completion checking of diffusion preprocessing """ def __init__(self): super().__init__() @property def processing_name(self): return 'DiffusionPreprocessing' if __name__ == "__main__": parser = my_argparse.MyArgumentParser( description="Program to check for completion of Diffusion Preprocessing for a single subject.") # mandatory arguments parser.add_argument('-w', '--working-dir', dest='working_dir', required=True, type=str) parser.add_argument('-s', '--subject', dest='subject', required=True, type=str) parser.add_argument('-c', '--classifier', dest='classifier', required=True, type=str) parser.add_argument('-f', '--fieldmap', dest='fieldmap', required=False, type=str, default='NONE') # optional arguments parser.add_argument('-v', '--verbose', dest='verbose', action='store_true', required=False, default=False) parser.add_argument('-o', '--output', dest='output', required=False, type=str) parser.add_argument('-a', '--check-all', dest='check_all', action='store_true', required=False, default=False) # parse the command line arguments