def __check_aligner_valid(self): """ If aligner was specified in input args, check that it is valid and fill in the appropriate parameter If aligner arg not correct, throw an exception """ self.__get_aligner_info() available_aligners = self.builder_params.get('available_aligners') default_aligner = self.builder_params.get('default_aligner') # if no aligner specified in commandline: if not self.builder_params.get('aligner'): logging.info('Setting aligner to default: %s', default_aligner) self.builder_params.reset_param('aligner', default_aligner) elif self.builder_params.get('aligner') not in available_aligners: logging.error('Incorrect aligner: %s', self.builder_params.get('aligner')) logging.error('Available aligners: %s', available_aligners) raise IncorrectAlignerException( "Unavailable aligner specified. Check log and correct as necessary." ) # now check that this aligner has a config file. Does not check that the aligner+genome is OK. # That is done when the aligner is invoked. chosen_genome = self.builder_params.get('genome') aligner = self.builder_params.get('aligner') aligner_specific_dir = os.path.join( self.builder_params.get('aligners_dir'), aligner) logging.info( 'Searching (but not parsing) for aligner configuration file in: %s', aligner_specific_dir) util_methods.locate_config(aligner_specific_dir) # create a component for the aligner: self.all_components.append(Component(aligner, aligner_specific_dir))
def __read_pipeline_config(self): # Read the pipeline-level config file config_filepath = util_methods.locate_config( self.builder_params.get('pipeline_home')) logging.info("Default pipeline configuration file is: %s", config_filepath) return cfg_parser.read_config(config_filepath)
def __get_aligner_info(self): """ Finds and parses the aligner configuration file-- this only indicates which aligners are available and which are default. Nothing specific to a particular aligner. """ aligner_cfg = util_methods.locate_config( self.builder_params.get('aligners_dir')) self.builder_params.add(cfg_parser.read_config(aligner_cfg))
def __get_available_components(self): """ """ components_dir = self.builder_params.get('components_dir') config_filepath = util_methods.locate_config(components_dir) # get the plugin parameters-- i.e. each component needs to have a script and entry method to call. plugin_parameters = cfg_parser.read_config(config_filepath, 'plugin_params') self.builder_params.add(plugin_parameters) entry_module = plugin_parameters[ 'entry_module'] #the script filename (minus the .py extension) entry_method = plugin_parameters['entry_method'] logging.info( "Search for available components with configuration file at: %s", config_filepath) available_components = cfg_parser.read_config(config_filepath, 'plugins') # the paths in the dictionary above are relative to the components_dir-- prepend that directory name for the full path available_components = { k: os.path.join(components_dir, available_components[k]) for k in available_components.keys() } # check that the plugin components have the required structure self.available_components = {} for k in available_components.keys(): if util_methods.component_structure_valid(available_components[k], entry_module, entry_method): self.available_components[k] = available_components[k] logging.info('Available components: ') logging.info(pretty_print(self.available_components)) # get the specifications for the standard components and the analysis components self.standard_components = [ c for c in cfg_parser.read_config(config_filepath, 'standard_plugins').values()[0] if c in self.available_components.keys() ] self.analysis_components = [ c for c in cfg_parser.read_config(config_filepath, 'analysis_plugins').values()[0] if c in self.available_components.keys() ] logging.info('Standard components: %s', self.standard_components) logging.info('Analysis components: %s', self.analysis_components)
def __check_project_config(self): """ Reads a project configuration file-- this configuration file lays out how a typical project is arranged in terms of file hierarchy, naming of fastq files, etc. Parameters are added to the builder_params object """ # Read the project-level config file if not self.builder_params.get('project_configuration_file'): default_filepath = util_methods.locate_config( self.builder_params.get('project_configurations_dir'), 'default') self.builder_params.reset_param('project_configuration_file', default_filepath) config_filepath = self.builder_params.get('project_configuration_file') logging.info("Project configuration file is: %s", config_filepath) self.builder_params.add(cfg_parser.read_config(config_filepath))
def __check_genome_valid(self): """ Ensure that the desired genome is acceptable. If not, throw an exception If the appropriate genome is found, read-in the genome parameters (e.g. path to GTF file, etc) """ genomes_dir = self.builder_params.get('genomes_dir') selected_genome = self.builder_params.get('genome') try: config_filepath = util_methods.locate_config(genomes_dir) self.builder_params.add( cfg_parser.read_config(config_filepath, selected_genome)) except Exception as ex: logging.error( 'Caught exception while looking for genome configuration file: ' ) logging.error(ex.message) logging.error('Incorrect genome: %s', selected_genome) logging.error('See available genomes in : %s', genomes_dir) raise IncorrectGenomeException( "Incorrect or unconfigured genome specified. Check log and correct as necessary." )