def main(argv=None): """ The main method for the tool. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description='Store a catalog data table in a PostgreSQL database table' ) cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_input_file_argument(parser, TOOL_NAME) cli_utils.add_output_arguments(parser, TOOL_NAME) cli_utils.add_database_arguments(parser, TOOL_NAME) cli_utils.add_catalog_table_argument(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # if input file path given, check the file path for validity input_file = args.get('input_file') cli_utils.check_input_file( input_file, TOOL_NAME) # may system exit here and not return! # if database config file path given, check the file path for validity dbconfig_file = args.get('dbconfig_file') cli_utils.check_dbconfig_file( dbconfig_file, TOOL_NAME) # may system exit here and not return! # if database config file path given, check the file path for validity catalog_table = args.get('catalog_table') cli_utils.check_catalog_table( catalog_table, TOOL_NAME) # may system exit here and not return! # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # call the task layer to process the given, validated input file try: task = FitsCatalogFillTableSink(args) task.input_process_output() except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) sys.exit(pe.error_code)
def main(argv=None): """ The main method for the tool. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description= 'Calculate values from incoming metadata, add the calculated fields to the metadata structure, and output it.' ) cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_input_file_argument(parser, TOOL_NAME) cli_utils.add_fits_file_argument(parser, TOOL_NAME) cli_utils.add_hdu_argument(parser, TOOL_NAME) cli_utils.add_collection_argument(parser, TOOL_NAME) cli_utils.add_output_arguments(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # if input file path given, check the file path for validity input_file = args.get('input_file') cli_utils.check_input_file( input_file, TOOL_NAME) # may system exit here and not return! # check the required FITS file path for validity fits_file = args.get('fits_file') cli_utils.check_fits_file( fits_file, TOOL_NAME) # may system exit here and not return! # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # call the task layer to process the given, validated files try: task = JWST_ObsCoreCalcTask(args) task.input_process_output() except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) sys.exit(pe.error_code)
def main(argv=None): """ The main method for the tool. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description= 'Add aliases for column names of a catalog metadata structure and output it.' ) cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_input_file_argument(parser, TOOL_NAME) cli_utils.add_aliases_argument(parser, TOOL_NAME, default_msg=DEFAULT_CAT_ALIASES_FILEPATH) cli_utils.add_output_arguments(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # if input file path given, check the file path for validity input_file = args.get('input_file') cli_utils.check_input_file(input_file, TOOL_NAME) # may exit here and not return! # if aliases file path given, check the file path for validity alias_file = args.get('alias_file') cli_utils.check_alias_file(alias_file, TOOL_NAME) # may exit here and not return! # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # call the task layer to process the given, validated input file try: task = CatalogAliasesTask(args) task.input_process_output() except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) sys.exit(pe.error_code)
def test_add_output_arguments(self): parser = argparse.ArgumentParser( formatter_class=argparse.RawTextHelpFormatter) utils.add_output_arguments(parser, TOOL_NAME) args = vars(parser.parse_args([])) print(args) assert 'output_file' not in args # no default assert 'gen_file_path' in args # it has a default args = vars(parser.parse_args(['-of', 'output.json'])) print(args) assert 'output_file' in args assert 'gen_file_path' in args # it has a default args = vars( parser.parse_args( ['--output-file', '/fake/output.json', '--generate'])) print(args) assert 'output_file' in args assert 'gen_file_path' in args
def main(argv=None): """ The main method for the pipeline. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description= 'Pipeline to extract image metadata from iRods FITS files and store into a PostreSQL/JSON hybrid database.' ) cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_input_dir_argument(parser, TOOL_NAME) cli_utils.add_hdu_argument(parser, TOOL_NAME) cli_utils.add_ignore_list_argument(parser, TOOL_NAME) cli_utils.add_aliases_argument(parser, TOOL_NAME) cli_utils.add_fields_info_argument(parser, TOOL_NAME) cli_utils.add_collection_argument(parser, TOOL_NAME) cli_utils.add_report_format_argument(parser, TOOL_NAME) cli_utils.add_output_arguments(parser, TOOL_NAME) cli_utils.add_database_arguments(parser, TOOL_NAME, table_msg=DEFAULT_HYBRID_TABLE_NAME) cli_utils.add_table_name_argument(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # get an instance of the iRods accessor class firh = FitsIRodsHelper(args) # instantiate the tasks which form the pipeline irods_fits_image_mdTask = IRodsFitsImageMetadataTask(args, firh) image_aliasesTask = ImageAliasesTask(args) fields_infoTask = FieldsInfoTask(args) irods_jwst_oc_calcTask = IRods_JWST_ObsCoreCalcTask(args, firh) miss_reportTask = MissingFieldsTask(args) jwst_pghyb_sinkTask = JWST_HybridPostgreSQLSink(args) # get and check the required image directory path for validity input_dir = args.get('input_dir') if (not firh.collection_exists(input_dir)): firh.cleanup() # cleanup resources opened here cli_utils.irods_input_dir_exit( TOOL_NAME, input_dir) # error exit out here: never returns # make of list of absolute iRods file paths pointing to FITS files ir_dir = firh.getc(input_dir, absolute=True) irff_paths = [fpath for fpath in firh.gen_fits_file_paths(ir_dir)] # call the pipeline on each FITS file in the input directory: if (args.get('verbose')): print("({}): Processing FITS files in '{}'.".format( TOOL_NAME, input_dir), file=sys.stderr) proc_count = 0 # initialize count of processed files for irff_path in irff_paths: args[ 'irods_fits_file'] = irff_path # reset the FITS file argument to next file if (args.get('verbose')): print("({}): Processing FITS file '{}'.".format( TOOL_NAME, irff_path), file=sys.stderr) try: jwst_pghyb_sinkTask.output_results( # sink: nothing returned miss_reportTask.process( # report: passes data through irods_jwst_oc_calcTask.process( fields_infoTask.process( image_aliasesTask.process( irods_fits_image_mdTask.process( None)))))) # metadata source proc_count += 1 # increment count of processed files except errors.UnsupportedType as ute: errMsg = "({}): WARNING: Unsupported File Type ({}): {}".format( TOOL_NAME, ute.error_code, ute.message) print(errMsg, file=sys.stderr) except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) # call cleanup method for tasks which opened resources jwst_pghyb_sinkTask.cleanup() irods_jwst_oc_calcTask.cleanup() irods_fits_image_mdTask.cleanup() firh.cleanup() # cleanup resources opened here if (args.get('verbose')): print("({}): Processed iRods {} FITS files.".format( TOOL_NAME, proc_count), file=sys.stderr)
def main(argv=None): """ The main method for the pipeline. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description= 'Pipeline to store catalog data in an existing PostgreSQL database table.' ) cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_input_file_argument(parser, TOOL_NAME) cli_utils.add_fits_file_argument(parser, TOOL_NAME) cli_utils.add_catalog_hdu_argument(parser, TOOL_NAME) cli_utils.add_output_arguments(parser, TOOL_NAME) cli_utils.add_database_arguments(parser, TOOL_NAME) cli_utils.add_catalog_table_argument(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # if input file path given, check the file path for validity input_file = args.get('input_file') cli_utils.check_input_file( input_file, TOOL_NAME) # may system exit here and not return! # check the required FITS file path for validity fits_file = args.get('fits_file') cli_utils.check_fits_file( fits_file, TOOL_NAME) # may system exit here and not return! # if database config file path given, check the file path for validity dbconfig_file = args.get('dbconfig_file') cli_utils.check_dbconfig_file( dbconfig_file, TOOL_NAME) # may system exit here and not return! # if database config file path given, check the file path for validity catalog_table = args.get('catalog_table') cli_utils.check_catalog_table( catalog_table, TOOL_NAME) # may system exit here and not return! # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # instantiate the tasks which form the pipeline fits_catalog_dataTask = FitsCatalogDataTask(args) fits_catalog_fillTask = FitsCatalogFillTableSink(args) # compose and call the pipeline tasks if (args.get('verbose')): print("({}): Processing FITS file '{}'.".format(TOOL_NAME, fits_file), file=sys.stderr) try: fits_catalog_fillTask.output_results( # sink to DB: nothing returned fits_catalog_dataTask.process(None)) # data source except errors.UnsupportedType as ute: errMsg = "({}): WARNING: Unsupported File Type ({}): {}".format( TOOL_NAME, ute.error_code, ute.message) print(errMsg, file=sys.stderr) sys.exit(ute.error_code) except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) sys.exit(pe.error_code) if (args.get('verbose')): print("({}): Processed FITS file '{}'.".format(TOOL_NAME, fits_file), file=sys.stderr)
def main (argv=None): """ The main method for the tool. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description='Extract image metadata from an iRods-resident FITS file and output it as JSON.' ) cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_hdu_argument(parser, TOOL_NAME) cli_utils.add_ignore_list_argument(parser, TOOL_NAME) cli_utils.add_output_arguments(parser, TOOL_NAME) cli_utils.add_irods_fits_file_argument(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # get the iRods file path argument of the file to be opened irff_path = args.get('irods_fits_file') # the specified FITS file must have a valid FITS extension cli_utils.check_irods_fits_file(irff_path, TOOL_NAME) # may system exit here and not return! # get an instance of the iRods accessor class firh = FitsIRodsHelper(args) # instantiate the task task = IRodsFitsImageMetadataTask(args, firh) if (args.get('verbose')): print("({}): Processing iRods FITS file '{}'.".format(TOOL_NAME, irff_path), file=sys.stderr) # call the task layer to process the given, unvalidated remote iRods FITS file try: task.process_and_output() except errors.UnsupportedType as ute: errMsg = "({}): WARNING: Unsupported File Type ({}): {}".format( TOOL_NAME, ute.error_code, ute.message) print(errMsg, file=sys.stderr) sys.exit(ute.error_code) except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) sys.exit(pe.error_code) finally: task.cleanup() firh.cleanup() # cleanup resources opened here if (args.get('verbose')): print("({}): Processed iRods FITS file '{}'.".format(TOOL_NAME, irff_path), file=sys.stderr)
def main(argv=None): """ The main method for the pipeline. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description= 'Pipeline to extract iRods FITS image metadata and store it into a PostreSQL/JSON hybrid database.' ) cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_irods_fits_file_argument(parser, TOOL_NAME) cli_utils.add_hdu_argument(parser, TOOL_NAME) cli_utils.add_ignore_list_argument(parser, TOOL_NAME) cli_utils.add_aliases_argument(parser, TOOL_NAME) cli_utils.add_fields_info_argument(parser, TOOL_NAME) cli_utils.add_collection_argument(parser, TOOL_NAME) cli_utils.add_report_format_argument(parser, TOOL_NAME) cli_utils.add_output_arguments(parser, TOOL_NAME) cli_utils.add_database_arguments(parser, TOOL_NAME, table_msg=DEFAULT_HYBRID_TABLE_NAME) cli_utils.add_table_name_argument(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # get the iRods file path argument of the file to be opened irff_path = args.get('irods_fits_file') # the specified FITS file must have a valid FITS extension cli_utils.check_irods_fits_file( irff_path, TOOL_NAME) # may system exit here and not return! # get an instance of the iRods accessor class firh = FitsIRodsHelper(args) # instantiate the tasks which form the pipeline irods_fits_image_mdTask = IRodsFitsImageMetadataTask(args, firh) image_aliasesTask = ImageAliasesTask(args) fields_infoTask = FieldsInfoTask(args) irods_jwst_oc_calcTask = IRods_JWST_ObsCoreCalcTask(args, firh) miss_reportTask = MissingFieldsTask(args) jwst_pghybrid_sinkTask = JWST_HybridPostgreSQLSink(args) if (args.get('verbose')): print("({}): Processing iRods FITS file '{}'.".format( TOOL_NAME, irff_path), file=sys.stderr) # compose and call the pipeline tasks try: jwst_pghybrid_sinkTask.output_results( # sink: nothing returned miss_reportTask.process( # report: passes data through irods_jwst_oc_calcTask.process( fields_infoTask.process( image_aliasesTask.process( irods_fits_image_mdTask.process( None)))))) # metadata source except errors.UnsupportedType as ute: errMsg = "({}): WARNING: Unsupported File Type ({}): {}".format( TOOL_NAME, ute.error_code, ute.message) print(errMsg, file=sys.stderr) sys.exit(ute.error_code) except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) sys.exit(pe.error_code) finally: # call cleanup method for tasks which opened resources jwst_pghybrid_sinkTask.cleanup() irods_jwst_oc_calcTask.cleanup() irods_fits_image_mdTask.cleanup() firh.cleanup() # cleanup resources opened here if (args.get('verbose')): print("({}): Processed iRods FITS file '{}'.".format( TOOL_NAME, irff_path), file=sys.stderr)
def main(argv=None): """ The main method for the tool. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description= 'Extract a catalog data table from a FITS file and output it as JSON.') cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_fits_file_argument(parser, TOOL_NAME) cli_utils.add_catalog_hdu_argument(parser, TOOL_NAME) cli_utils.add_output_arguments(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # check the required FITS file path for validity fits_file = args.get('fits_file') cli_utils.check_fits_file( fits_file, TOOL_NAME) # may system exit here and not return! # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # call the task layer to process the given, validated FITS file if (args.get('verbose')): print("({}): Processing FITS file '{}'.".format(TOOL_NAME, fits_file), file=sys.stderr) try: task = FitsCatalogDataTask(args) task.process_and_output() except errors.UnsupportedType as ute: errMsg = "({}): WARNING: Unsupported File Type ({}): {}".format( TOOL_NAME, ute.error_code, ute.message) print(errMsg, file=sys.stderr) sys.exit(ute.error_code) except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) sys.exit(pe.error_code) if (args.get('verbose')): print("({}): Processed FITS file '{}'.".format(TOOL_NAME, fits_file), file=sys.stderr)
def main(argv=None): """ The main method for the pipeline. This method is called from the command line, processes the command line arguments and calls into the ImdTk library to do its work. This main method takes no arguments so it can be called by setuptools. """ # the main method takes no arguments so it can be called by setuptools if (argv is None): # if called by setuptools argv = sys.argv[1:] # then fetch the arguments from the system # setup command line argument parsing and add shared arguments parser = argparse.ArgumentParser( prog=TOOL_NAME, formatter_class=argparse.RawTextHelpFormatter, description= 'Pipeline to extract image metadata and store it into a PostreSQL database.' ) cli_utils.add_shared_arguments(parser, TOOL_NAME) cli_utils.add_input_dir_argument(parser, TOOL_NAME) cli_utils.add_hdu_argument(parser, TOOL_NAME) cli_utils.add_ignore_list_argument(parser, TOOL_NAME) cli_utils.add_aliases_argument(parser, TOOL_NAME) cli_utils.add_fields_info_argument(parser, TOOL_NAME) cli_utils.add_collection_argument(parser, TOOL_NAME) cli_utils.add_report_format_argument(parser, TOOL_NAME) cli_utils.add_output_arguments(parser, TOOL_NAME) cli_utils.add_database_arguments(parser, TOOL_NAME) cli_utils.add_table_name_argument(parser, TOOL_NAME) # actually parse the arguments from the command line args = vars(parser.parse_args(argv)) # if debugging, set verbose and echo input arguments if (args.get('debug')): args['verbose'] = True # if debug turn on verbose too print("({}.main): ARGS={}".format(TOOL_NAME, args), file=sys.stderr) # check the required image directory path for validity input_dir = args.get('input_dir') cli_utils.check_input_dir( input_dir, TOOL_NAME) # may system exit here and not return! # add additional arguments to args args['TOOL_NAME'] = TOOL_NAME # instantiate the tasks which form the pipeline fits_image_mdTask = FitsImageMetadataTask(args) image_aliasesTask = ImageAliasesTask(args) fields_infoTask = FieldsInfoTask(args) jwst_oc_calcTask = JWST_ObsCoreCalcTask(args) miss_reportTask = MissingFieldsTask(args) jwst_pgsql_sinkTask = JWST_ObsCorePostgreSQLSink(args) # call the pipeline on each FITS file in the input directory: if (args.get('verbose')): print("({}): Processing FITS files in '{}'.".format( TOOL_NAME, input_dir), file=sys.stderr) proc_count = 0 # initialize count of processed files for img_file in gen_fits_file_paths(input_dir): args[ 'fits_file'] = img_file # reset the FITS file argument to next file if (args.get('verbose')): print("({}): Processing FITS file '{}'.".format( TOOL_NAME, img_file), file=sys.stderr) try: jwst_pgsql_sinkTask.output_results( # sink: nothing returned miss_reportTask.process( # report: passes data through jwst_oc_calcTask.process( fields_infoTask.process( image_aliasesTask.process( fits_image_mdTask.process( None)))))) # metadata source proc_count += 1 # increment count of processed files except errors.UnsupportedType as ute: errMsg = "({}): WARNING: Unsupported File Type ({}): {}".format( TOOL_NAME, ute.error_code, ute.message) print(errMsg, file=sys.stderr) except errors.ProcessingError as pe: errMsg = "({}): ERROR: Processing Error ({}): {}".format( TOOL_NAME, pe.error_code, pe.message) print(errMsg, file=sys.stderr) if (args.get('verbose')): print("({}): Processed {} FITS files.".format(TOOL_NAME, proc_count), file=sys.stderr)