docs: def search_and_extract_nucleotides_matching_nucleotide_database(self,
                                                        unpack,
                                                        euk_check,
                                                        search_method,
                                                        maximum_range,
                                                        threads,
                                                        evalue,
                                                        hmmsearch_output_table,
                                                        hit_reads_fasta):
          '''As per nt_db_search() except slightly lower level. Search an
          input read set (unpack) and then extract the sequences that hit.
  
          Parameters
          ----------
          hmmsearch_output_table: str
              path to hmmsearch output table
          hit_reads_fasta: str
              path to hit nucleotide sequences
          
          Returns
          -------
          direction_information: dict
                      
              {read_1: False
               ...
               read n: True}
              
              where True = Forward direction
              and False = Reverse direction
          
          result: DBSearchResult object containing file locations and hit 
          information
          '''
  
          if search_method == "hmmsearch":
              # First search the reads using the HMM
              search_result, table_list = self.nhmmer(
                                                      hmmsearch_output_table,
                                                      unpack,
                                                      threads,
                                                      evalue
                                                      )
  
  
          elif search_method == 'diamond':
              raise Exception("Diamond searches not supported for nucelotide databases yet")
  
          
          if maximum_range:  
              
              hits = self._get_read_names(
                                          search_result,  # define the span of hits
                                          maximum_range
                                          )
          else:   
              hits = self._get_sequence_directions(search_result)
  
          hit_readnames = hits.keys()
          
          if euk_check:
              euk_reads = self._check_euk_contamination(table_list)
              hit_readnames = set([read for read in hit_readnames if read not in euk_reads])
              hits = {key:item for key, item in  hits.iteritems() if key in hit_readnames}
              hit_read_count = [len(euk_reads), len(hit_readnames)]
          else:
              hit_read_count = [0, len(hit_readnames)]
          
          hit_reads_fasta, direction_information = self._extract_from_raw_reads(
                                                         hit_reads_fasta,
                                                         hit_readnames,
                                                         unpack.read_file,
                                                         unpack.format(),
                                                         hits
                                                         )
          
          if not hit_readnames:
              result = DBSearchResult(None,
                                    search_result,
                                    hit_read_count,
                                    None)
          else:
              slash_endings=self._check_for_slash_endings(hit_readnames)
              result = DBSearchResult(hit_reads_fasta,
                                      search_result,
                                      hit_read_count,
                                      slash_endings)
  
          if maximum_range:
              n_hits = sum([len(x["strand"]) for x in hits.values()])
          else:
              n_hits = len(hits)
          logging.info("%s read(s) detected" % n_hits)
          
          return result, direction_information