コード例 #1
0
ファイル: cutadapt.py プロジェクト: wgerlach/cutadapt
		def collect(back, anywhere, front):
			adapters = []
			for name, seq, where in gather_adapters(back, anywhere, front):
				if not seq:
					parser.error("The adapter sequence is empty.")
				adapter = ADAPTER_CLASS(seq, where, options.error_rate,
					options.overlap, options.match_read_wildcards,
					options.match_adapter_wildcards, name=name, indels=options.indels)
				if options.debug:
					adapter.enable_debug()
				adapters.append(adapter)
			return adapters
コード例 #2
0
ファイル: cutadapt.py プロジェクト: avilella/cutadapt
		def collect(back, anywhere, front):
			adapters = []
			for name, seq, where in gather_adapters(back, anywhere, front):
				if not seq:
					parser.error("The adapter sequence is empty.")
				if not options.indels and where not in (PREFIX, SUFFIX):
					parser.error("Not allowing indels is currently supported only for anchored 5' and 3' adapters.")
				adapter = ADAPTER_CLASS(seq, where, options.error_rate,
					options.overlap, options.match_read_wildcards,
					options.match_adapter_wildcards, name=name, indels=options.indels)
				adapters.append(adapter)
			return adapters
コード例 #3
0
 def collect(back, anywhere, front):
     adapters = []
     for name, seq, where in gather_adapters(back, anywhere, front):
         if not seq:
             parser.error("The adapter sequence is empty.")
         adapter = ADAPTER_CLASS(seq,
                                 where,
                                 options.error_rate,
                                 options.overlap,
                                 options.match_read_wildcards,
                                 options.match_adapter_wildcards,
                                 name=name,
                                 indels=options.indels)
         if options.debug:
             adapter.enable_debug()
         adapters.append(adapter)
     return adapters
コード例 #4
0
ファイル: trim_file.py プロジェクト: mattions/miRge
 def __init__(self, queue=None, results=None, adapter=None, phred64=False):
     super(Worker, self).__init__()
     self.queue=queue
     self.results = results
     self.phred = 64 if phred64 else 33
     self.modifiers = [QualityTrimmer(0, 10, self.phred)]
     self.adapters = []
     self.error_rate = 0.12
     self.min_length = 16
     if adapter.startswith('+'):
         self.modifiers.append(UnconditionalCutter(int(adapter)))
     elif adapter == 'none':
         self.adapter = None
     else:
         for name,seq,where in gather_adapters(adapter.split(','), [], []):
             self.adapters.append(Adapter(seq, where, self.error_rate, name=name))
         adapter_cutter = AdapterCutter(self.adapters)
         self.modifiers.append(adapter_cutter)
コード例 #5
0
def main(cmdlineargs=None, default_outfile=sys.stdout):
    """
	Main function that evaluates command-line parameters and iterates
	over all reads.

	default_outfile is the file to which trimmed reads are sent if the ``-o``
	parameter is not used.
	"""
    parser = get_option_parser()
    if cmdlineargs is None:
        cmdlineargs = sys.argv[1:]
    options, args = parser.parse_args(args=cmdlineargs)

    if len(args) == 0:
        parser.error("At least one parameter needed: name of a FASTA or FASTQ file.")
    elif len(args) > 2:
        parser.error("Too many parameters.")

    input_filename = args[0]

    # If a second file name was given, then we either have single-end reads
    # provided as a pair of .fasta/.qual files or we have paired-end reads.
    quality_filename = None
    input_paired_filename = None
    if len(args) == 2:
        if args[0].endswith(".qual"):
            parser.error("The QUAL file must be the second argument.")
        if args[1].endswith(".qual"):
            quality_filename = args[1]
        else:
            input_paired_filename = args[1]
            if not options.paired_output:
                parser.error("You must use --paired-output when trimming paired-end reads.")

    if len(args) == 1 and options.paired_output:
        parser.error("You specified a --paired-output file, but gave only one input file.")
    if options.paired_output and bool(options.untrimmed_output) != bool(options.untrimmed_paired_output):
        parser.error(
            "When trimming paired-end reads, you must use either none "
            "or both of the --untrimmed-output/--untrimmed-paired-output options."
        )
    if options.untrimmed_paired_output and not options.paired_output:
        parser.error(
            "Option --untrimmed-paired-output can only be used when "
            "trimming paired-end reads (with option --paired-output)."
        )
    if input_filename.endswith(".qual"):
        parser.error("Need a FASTA file in addition to the QUAL file.")

    if options.format is not None and options.format.lower() not in ["fasta", "fastq", "sra-fastq"]:
        parser.error(
            "The input file format must be either 'fasta', 'fastq' or "
            "'sra-fastq' (not '{0}').".format(options.format)
        )

        # TODO should this really be an error?
    if options.format is not None and quality_filename is not None:
        parser.error("If a pair of .fasta and .qual files is given, the -f/--format parameter cannot be used.")

    writers = []
    too_short_outfile = None  # too short reads go here
    too_short_filter = None
    # TODO pass file name to TooShortReadFilter, add a .close() method?
    if options.minimum_length > 0:
        if options.too_short_output:
            too_short_outfile = xopen(options.too_short_output, "w")
        else:
            too_short_outfile = None
        too_short_filter = TooShortReadFilter(options.minimum_length, too_short_outfile)
        writers.append(too_short_filter)
    too_long_outfile = None  # too long reads go here
    too_long_filter = None
    if options.maximum_length < sys.maxsize:
        if options.too_long_output is not None:
            too_long_outfile = xopen(options.too_long_output, "w")
        else:
            too_long_outfile = None
        too_long_filter = TooLongReadFilter(options.maximum_length, too_long_outfile)
        writers.append(too_long_filter)

    demultiplexer = None
    if options.output is not None and "{name}" in options.output:
        if options.discard_trimmed:
            parser.error("Do not use --discard-trimmed when demultiplexing.")
        if input_paired_filename:
            parser.error("Demultiplexing not supported for paired-end files, yet.")
        untrimmed = options.output.format(name="unknown")
        if options.untrimmed_output:
            untrimmed = options.untrimmed_output
        if options.discard_untrimmed:
            untrimmed = None
        demultiplexer = Demultiplexer(options.output, untrimmed)
        writers.append(demultiplexer)
        trimmed_outfile, untrimmed_outfile = None, None
        trimmed_paired_outfile, untrimmed_paired_outfile = None, None
    else:
        trimmed_outfile, untrimmed_outfile = trimmed_and_untrimmed_files(
            default_outfile,
            options.output,
            options.untrimmed_output,
            options.discard_trimmed,
            options.discard_untrimmed,
        )

        trimmed_paired_outfile, untrimmed_paired_outfile = trimmed_and_untrimmed_files(
            None,  # applies when not trimming paired-end data
            options.paired_output,
            options.untrimmed_paired_output,
            options.discard_trimmed,
            options.discard_untrimmed,
        )

        writer = ProcessedReadWriter(
            trimmed_outfile, trimmed_paired_outfile, untrimmed_outfile, untrimmed_paired_outfile
        )
        writers.append(writer)

    if options.maq:
        options.colorspace = True
        options.double_encode = True
        options.trim_primer = True
        options.strip_suffix.append("_F3")
        options.suffix = "/1"
    if options.zero_cap is None:
        options.zero_cap = options.colorspace
    if options.trim_primer and not options.colorspace:
        parser.error("Trimming the primer makes only sense in colorspace.")
    if options.double_encode and not options.colorspace:
        parser.error("Double-encoding makes only sense in colorspace.")
    if options.anywhere and options.colorspace:
        parser.error(
            "Using --anywhere with colorspace reads is currently not supported (if you think this may be useful, contact the author)."
        )
    if not (0 <= options.error_rate <= 1.0):
        parser.error("The maximum error rate must be between 0 and 1.")
    if options.overlap < 1:
        parser.error("The overlap must be at least 1.")

    if options.rest_file is not None:
        options.rest_file = xopen(options.rest_file, "w")
        rest_writer = RestFileWriter(options.rest_file)
    else:
        rest_writer = None
    if options.info_file is not None:
        options.info_file = xopen(options.info_file, "w")
    if options.wildcard_file is not None:
        options.wildcard_file = xopen(options.wildcard_file, "w")

    if options.colorspace:
        if options.match_read_wildcards:
            parser.error("IUPAC wildcards not supported in colorspace")
        options.match_adapter_wildcards = False
    adapters = []
    ADAPTER_CLASS = ColorspaceAdapter if options.colorspace else Adapter

    try:
        for name, seq, where in gather_adapters(options.adapters, options.anywhere, options.front):
            if not seq:
                parser.error("The adapter sequence is empty")
            if not options.indels and where not in (PREFIX, SUFFIX):
                parser.error("Not allowing indels is currently supported only for anchored 5' and 3' adapters.")
            adapter = ADAPTER_CLASS(
                seq,
                where,
                options.error_rate,
                options.overlap,
                options.match_read_wildcards,
                options.match_adapter_wildcards,
                name=name,
                indels=options.indels,
            )
            adapters.append(adapter)
    except IOError as e:
        if e.errno == errno.ENOENT:
            print("Error:", e, file=sys.stderr)
            sys.exit(1)
        raise

    if (
        not adapters
        and options.quality_cutoff == 0
        and options.cut == 0
        and options.minimum_length == 0
        and options.maximum_length == sys.maxsize
    ):
        parser.error("You need to provide at least one adapter sequence.")

    if input_paired_filename:
        reader = seqio.PairedSequenceReader(
            input_filename, input_paired_filename, colorspace=options.colorspace, fileformat=options.format
        )
    else:
        reader = read_sequences(
            input_filename, quality_filename, colorspace=options.colorspace, fileformat=options.format
        )

        # Create the processing pipeline as a list of "modifiers".
    modifiers = []
    if options.cut:
        if len(options.cut) > 2:
            parser.error("You cannot remove bases from more than two ends.")
        if len(options.cut) == 2 and options.cut[0] * options.cut[1] > 0:
            parser.error("You cannot remove bases from the same end twice.")
        for cut in options.cut:
            if cut != 0:
                modifiers.append(UnconditionalCutter(cut))

    if options.quality_cutoff > 0:
        modifiers.append(QualityTrimmer(options.quality_cutoff, options.quality_base))
    if adapters:
        adapter_cutter = AdapterCutter(
            adapters, options.times, options.wildcard_file, options.info_file, rest_writer, options.action
        )
        modifiers.append(adapter_cutter)
    else:
        adapter_cutter = None
    if options.length_tag:
        modifiers.append(LengthTagModifier(options.length_tag))
    if options.strip_f3:
        options.strip_suffix.append("_F3")
    for suffix in options.strip_suffix:
        modifiers.append(SuffixRemover(suffix))
    if options.prefix or options.suffix:
        modifiers.append(PrefixSuffixAdder(options.prefix, options.suffix))
    if options.double_encode:
        modifiers.append(DoubleEncoder())
    if options.zero_cap and reader.delivers_qualities:
        modifiers.append(ZeroCapper(quality_base=options.quality_base))
    if options.trim_primer:
        modifiers.append(PrimerTrimmer)

    start_time = time.clock()
    try:
        if input_paired_filename:
            stats = process_paired_reads(reader, modifiers, writers)
        else:
            stats = process_single_reads(reader, modifiers, writers)
    except KeyboardInterrupt as e:
        print("Interrupted", file=sys.stderr)
        sys.exit(1)
    except IOError as e:
        if e.errno == errno.EPIPE:
            sys.exit(1)
        raise
    except seqio.FormatError as e:
        print("Error:", e, file=sys.stderr)
        sys.exit(1)

        # close open files
    for f in [
        trimmed_outfile,
        untrimmed_outfile,
        trimmed_paired_outfile,
        untrimmed_paired_outfile,
        options.rest_file,
        options.wildcard_file,
        options.info_file,
        too_short_outfile,
        too_long_outfile,
        options.info_file,
        demultiplexer,
    ]:
        if f is not None and f is not sys.stdin and f is not sys.stdout:
            f.close()

    if not options.quiet:
        # send statistics to stderr if result was sent to stdout
        stat_file = sys.stderr if options.output is None else None
        print_statistics(
            adapters,
            time.clock() - start_time,
            stats,
            options.action,
            adapter_cutter.reads_matched if adapter_cutter else 0,
            options.error_rate,
            too_short_filter.too_short if too_short_filter else 0,
            too_long_filter.too_long if too_long_filter else 0,
            cmdlineargs,
            file=stat_file,
        )
コード例 #6
0
def main(cmdlineargs=None, default_outfile=sys.stdout):
	"""
	Main function that evaluates command-line parameters and iterates
	over all reads.

	default_outfile is the file to which trimmed reads are sent if the ``-o``
	parameter is not used.
	"""
	logging.basicConfig(level=logging.INFO, format='%(message)s')  #  %(levelname)s
	parser = get_option_parser()
	if cmdlineargs is None:
		cmdlineargs = sys.argv[1:]
	options, args = parser.parse_args(args=cmdlineargs)

	if len(args) == 0:
		parser.error("At least one parameter needed: name of a FASTA or FASTQ file.")
	elif len(args) > 2:
		parser.error("Too many parameters.")
	input_filename = args[0]

	# Find out which 'mode' we need to use.
	# Default: single-read trimming (neither -p nor -A/-G/-B/-U given)
	paired = False
	if options.paired_output:
		# Modify first read only, keep second in sync (-p given, but not -A/-G/-B/-U).
		# This exists for backwards compatibility ('legacy mode').
		paired = 'first'
	if options.adapters2 or options.front2 or options.anywhere2 or options.cut2:
		# Full paired-end trimming when both -p and -A/-G/-B/-U given
		# Also the read modifications (such as quality trimming) are applied
		# to second read.
		paired = 'both'

	if paired and len(args) == 1:
		parser.error("When paired-end trimming is enabled via -A/-G/-B/-U or -p, "
			"two input files are required.")
	if paired:
		input_paired_filename = args[1]
		quality_filename = None
	else:
		input_paired_filename = None
		if len(args) == 2:
			if args[0].endswith('.qual'):
				parser.error("The QUAL file must be the second argument.")
			quality_filename = args[1]
		else:
			quality_filename = None

	if paired:
		if not options.paired_output:
			parser.error("When paired-end trimming is enabled via -A/-G/-B/-U, "
				"a second output file needs to be specified via -p (--paired-output).")
		if bool(options.untrimmed_output) != bool(options.untrimmed_paired_output):
			parser.error("When trimming paired-end reads, you must use either none "
				"or both of the --untrimmed-output/--untrimmed-paired-output options.")
	else:
		if options.untrimmed_paired_output:
			parser.error("Option --untrimmed-paired-output can only be used when "
				"trimming paired-end reads (with option -p).")
		if input_filename.endswith('.qual'):
			parser.error("Need a FASTA file in addition to the QUAL file.")
		if options.format is not None and quality_filename is not None:
			parser.error("If a pair of .fasta and .qual files is given, the -f/--format parameter cannot be used.")

	if options.format is not None and options.format.lower() not in ['fasta', 'fastq', 'sra-fastq']:
		parser.error("The input file format must be either 'fasta', 'fastq' or "
			"'sra-fastq' (not '{0}').".format(options.format))

	if options.quality_cutoff is not None:
		cutoffs = options.quality_cutoff.split(',')
		if len(cutoffs) == 1:
			try:
				cutoffs = [0, int(cutoffs[0])]
			except ValueError as e:
				parser.error("Quality cutoff value not recognized: {0}".format(e))
		elif len(cutoffs) == 2:
			try:
				cutoffs = [int(cutoffs[0]), int(cutoffs[1])]
			except ValueError as e:
				parser.error("Quality cutoff value not recognized: {0}".format(e))
		else:
			parser.error("Expected one value or two values separated by comma for the quality cutoff")
	else:
		cutoffs = None
	writers = []
	too_short_outfile = None  # too short reads go here
	too_short_filter = None
	# TODO pass file name to TooShortReadFilter, add a .close() method?
	if options.minimum_length > 0:
		if options.too_short_output:
			too_short_outfile = xopen(options.too_short_output, 'w')
		else:
			too_short_outfile = None
		too_short_filter = TooShortReadFilter(options.minimum_length,
			too_short_outfile, paired=='both')
		writers.append(too_short_filter)
	too_long_outfile = None  # too long reads go here
	too_long_filter = None
	if options.maximum_length < sys.maxsize:
		if options.too_long_output is not None:
			too_long_outfile = xopen(options.too_long_output, 'w')
		else:
			too_long_outfile = None
		too_long_filter = TooLongReadFilter(options.maximum_length,
			too_long_outfile, check_second=paired=='both')
		writers.append(too_long_filter)

	if options.max_n != -1:
		writers.append(NContentTrimmer(options.max_n, check_second=paired=='both'))

	demultiplexer = None
	if options.output is not None and '{name}' in options.output:
		if options.discard_trimmed:
			parser.error("Do not use --discard-trimmed when demultiplexing.")
		if paired:
			parser.error("Demultiplexing not supported for paired-end files, yet.")
		untrimmed = options.output.format(name='unknown')
		if options.untrimmed_output:
			untrimmed = options.untrimmed_output
		if options.discard_untrimmed:
			untrimmed = None
		demultiplexer = Demultiplexer(options.output, untrimmed)
		writers.append(demultiplexer)
		trimmed_outfile, untrimmed_outfile = None, None
		trimmed_paired_outfile, untrimmed_paired_outfile = None, None
	else:
		trimmed_outfile, untrimmed_outfile = trimmed_and_untrimmed_files(
			default_outfile,
			options.output,
			options.untrimmed_output,
			options.discard_trimmed,
			options.discard_untrimmed)

		trimmed_paired_outfile, untrimmed_paired_outfile = trimmed_and_untrimmed_files(
			None,  # applies when not trimming paired-end data
			options.paired_output,
			options.untrimmed_paired_output,
			options.discard_trimmed,
			options.discard_untrimmed)

		writer = ProcessedReadWriter(
			trimmed_outfile, trimmed_paired_outfile,
			untrimmed_outfile, untrimmed_paired_outfile,
			check_second=paired=='both'
		)
		writers.append(writer)

	if options.maq:
		options.colorspace = True
		options.double_encode = True
		options.trim_primer = True
		options.strip_suffix.append('_F3')
		options.suffix = "/1"
	if options.zero_cap is None:
		options.zero_cap = options.colorspace
	if options.trim_primer and not options.colorspace:
		parser.error("Trimming the primer makes only sense in colorspace.")
	if options.double_encode and not options.colorspace:
		parser.error("Double-encoding makes only sense in colorspace.")
	if options.anywhere and options.colorspace:
		parser.error("Using --anywhere with colorspace reads is currently not supported (if you think this may be useful, contact the author).")
	if not (0 <= options.error_rate <= 1.):
		parser.error("The maximum error rate must be between 0 and 1.")
	if options.overlap < 1:
		parser.error("The overlap must be at least 1.")

	if options.rest_file is not None:
		options.rest_file = xopen(options.rest_file, 'w')
		rest_writer = RestFileWriter(options.rest_file)
	else:
		rest_writer = None
	if options.info_file is not None:
		options.info_file = xopen(options.info_file, 'w')
	if options.wildcard_file is not None:
		options.wildcard_file = xopen(options.wildcard_file, 'w')

	if options.colorspace:
		if options.match_read_wildcards:
			parser.error('IUPAC wildcards not supported in colorspace')
		options.match_adapter_wildcards = False

	ADAPTER_CLASS = ColorspaceAdapter if options.colorspace else Adapter
	try:
		# TODO refactor, code duplicated
		adapters = []
		for name, seq, where in gather_adapters(options.adapters, options.anywhere, options.front):
			if not seq:
				parser.error("The adapter sequence is empty.")
			if not options.indels and where not in (PREFIX, SUFFIX):
				parser.error("Not allowing indels is currently supported only for anchored 5' and 3' adapters.")
			adapter = ADAPTER_CLASS(seq, where, options.error_rate,
				options.overlap, options.match_read_wildcards,
				options.match_adapter_wildcards, name=name, indels=options.indels)
			adapters.append(adapter)
		adapters2 = []
		for name, seq, where in gather_adapters(options.adapters2, options.anywhere2, options.front2):
			if not seq:
				parser.error("The adapter sequence is empty.")
			if not options.indels and where != PREFIX:
				parser.error("Not allowing indels is currently supported only for anchored 5' and 3' adapters.")
			adapter = ADAPTER_CLASS(seq, where, options.error_rate,
				options.overlap, options.match_read_wildcards,
				options.match_adapter_wildcards, name=name, indels=options.indels)
			adapters2.append(adapter)
	except IOError as e:
		if e.errno == errno.ENOENT:
			parser.error(e)
		raise

	if not adapters and not adapters2 and not cutoffs and \
			options.cut == [] and options.cut2 == [] and \
			options.minimum_length == 0 and \
			options.maximum_length == sys.maxsize and \
			quality_filename is None and \
			options.max_n == -1:
		parser.error("You need to provide at least one adapter sequence.")

	try:
		reader = seqio.open(input_filename, file2=input_paired_filename,
				qualfile=quality_filename, colorspace=options.colorspace,
				fileformat=options.format)
	except (seqio.UnknownFileType, IOError) as e:
		parser.error(e)

	# Create the processing pipeline consisting of a list of "modifiers".
	modifiers = []
	if options.cut:
		if len(options.cut) > 2:
			parser.error("You cannot remove bases from more than two ends.")
		if len(options.cut) == 2 and options.cut[0] * options.cut[1] > 0:
			parser.error("You cannot remove bases from the same end twice.")
		for cut in options.cut:
			if cut != 0:
				modifiers.append(UnconditionalCutter(cut))

	if cutoffs:
		modifiers.append(QualityTrimmer(cutoffs[0], cutoffs[1], options.quality_base))
	if adapters:
		adapter_cutter = AdapterCutter(adapters, options.times,
				options.wildcard_file, options.info_file,
				rest_writer, options.action)
		modifiers.append(adapter_cutter)
	else:
		adapter_cutter = None

	# Modifiers that apply to both reads of paired-end reads
	modifiers_both = []
	if options.trim_n:
		modifiers_both.append(NEndTrimmer())
	if options.length_tag:
		modifiers_both.append(LengthTagModifier(options.length_tag))
	if options.strip_f3:
		options.strip_suffix.append('_F3')
	for suffix in options.strip_suffix:
		modifiers_both.append(SuffixRemover(suffix))
	if options.prefix or options.suffix:
		modifiers_both.append(PrefixSuffixAdder(options.prefix, options.suffix))
	if options.double_encode:
		modifiers_both.append(DoubleEncoder())
	if options.zero_cap and reader.delivers_qualities:
		modifiers_both.append(ZeroCapper(quality_base=options.quality_base))
	if options.trim_primer:
		modifiers_both.append(PrimerTrimmer)
	modifiers.extend(modifiers_both)

	# For paired-end data, create a second processing pipeline.
	# However, if no second-read adapters were given (via -A/-G/-B/-U), we need to
	# be backwards compatible and *no modifications* are done to the second read.
	modifiers2 = []
	if paired == 'both':
		if options.cut2:
			if len(options.cut2) > 2:
				parser.error("You cannot remove bases from more than two ends.")
			if len(options.cut2) == 2 and options.cut2[0] * options.cut2[1] > 0:
				parser.error("You cannot remove bases from the same end twice.")
			for cut in options.cut2:
				if cut != 0:
					modifiers2.append(UnconditionalCutter(cut))

		if cutoffs:
			modifiers2.append(QualityTrimmer(cutoffs[0], cutoffs[1], options.quality_base))
		if adapters2:
			adapter_cutter2 = AdapterCutter(adapters2, options.times,
					None, None, None, options.action)
			modifiers2.append(adapter_cutter2)
		else:
			adapter_cutter2 = None
		modifiers2.extend(modifiers_both)

	# Due to backwards compatibility, from here on logging output needs to be
	# sent to standard output instead of standard error if the -o option is used.
	if options.output:
		logger.root.handlers = []
		logging.basicConfig(level=logging.INFO, format='%(message)s', stream=sys.stdout)
	logger.info("This is cutadapt %s with Python %s", __version__, platform.python_version())
	logger.info("Command line parameters: %s", " ".join(cmdlineargs))
	logger.info("Trimming %s adapter%s with at most %.1f%% errors in %s mode ...",
		len(adapters) + len(adapters2), 's' if len(adapters) + len(adapters2) != 1 else '',
		options.error_rate * 100,
		{ False: 'single-end', 'first': 'paired-end legacy', 'both': 'paired-end' }[paired])

	start_time = time.clock()
	try:
		if paired:
			stats = process_paired_reads(reader, modifiers, modifiers2, writers)
		else:
			stats = process_single_reads(reader, modifiers, writers)
	except KeyboardInterrupt as e:
		print("Interrupted", file=sys.stderr)
		sys.exit(130)
	except IOError as e:
		if e.errno == errno.EPIPE:
			sys.exit(1)
		raise
	except (seqio.FormatError, EOFError) as e:
		sys.exit("cutadapt: error: {0}".format(e))

	# close open files
	for f in [trimmed_outfile, untrimmed_outfile, trimmed_paired_outfile,
			untrimmed_paired_outfile, options.rest_file, options.wildcard_file,
			options.info_file, too_short_outfile, too_long_outfile,
			options.info_file, demultiplexer]:
		if f is not None and f is not sys.stdin and f is not sys.stdout:
			f.close()

	elapsed_time = time.clock() - start_time
	if not options.quiet:
		stats.collect((adapters, adapters2), elapsed_time,
			modifiers, modifiers2, writers)
		# send statistics to stderr if result was sent to stdout
		stat_file = sys.stderr if options.output is None else None
		with redirect_standard_output(stat_file):
			print_report(stats, (adapters, adapters2))
コード例 #7
0
 def parse_adapters(adapter, error_rate=None):
     adapters = []
     for name, seq, where in gather_adapters(adapter.split(','), [], []):
         adapters.append(Adapter(seq, where, error_rate, name=name))
     return adapters
コード例 #8
0
def main(cmdlineargs=None, default_outfile=sys.stdout):
    """
	Main function that evaluates command-line parameters and iterates
	over all reads.

	default_outfile is the file to which trimmed reads are sent if the ``-o``
	parameter is not used.
	"""
    parser = get_option_parser()
    if cmdlineargs is None:
        cmdlineargs = sys.argv[1:]
    options, args = parser.parse_args(args=cmdlineargs)

    if len(args) == 0:
        parser.error(
            "At least one parameter needed: name of a FASTA or FASTQ file.")
    elif len(args) > 2:
        parser.error("Too many parameters.")

    input_filename = args[0]

    # If a second file name was given, then we either have single-end reads
    # provided as a pair of .fasta/.qual files or we have paired-end reads.
    quality_filename = None
    input_paired_filename = None
    if len(args) == 2:
        if args[0].endswith('.qual'):
            parser.error("The QUAL file must be the second argument.")
        if args[1].endswith('.qual'):
            quality_filename = args[1]
        else:
            input_paired_filename = args[1]
            if not options.paired_output:
                parser.error(
                    'You must use --paired-output when trimming paired-end reads.'
                )

    if len(args) == 1 and options.paired_output:
        parser.error(
            "You specified a --paired-output file, but gave only one input file."
        )
    if options.paired_output and bool(options.untrimmed_output) != bool(
            options.untrimmed_paired_output):
        parser.error(
            "When trimming paired-end reads, you must use either none "
            "or both of the --untrimmed-output/--untrimmed-paired-output options."
        )
    if options.untrimmed_paired_output and not options.paired_output:
        parser.error(
            "Option --untrimmed-paired-output can only be used when "
            "trimming paired-end reads (with option --paired-output).")
    if input_filename.endswith('.qual'):
        parser.error("Need a FASTA file in addition to the QUAL file.")

    if options.format is not None and options.format.lower() not in [
            'fasta', 'fastq', 'sra-fastq'
    ]:
        parser.error(
            "The input file format must be either 'fasta', 'fastq' or "
            "'sra-fastq' (not '{0}').".format(options.format))

    # TODO should this really be an error?
    if options.format is not None and quality_filename is not None:
        parser.error(
            "If a pair of .fasta and .qual files is given, the -f/--format parameter cannot be used."
        )

    writers = []
    too_short_outfile = None  # too short reads go here
    too_short_filter = None
    # TODO pass file name to TooShortReadFilter, add a .close() method?
    if options.minimum_length > 0:
        if options.too_short_output:
            too_short_outfile = xopen(options.too_short_output, 'w')
        else:
            too_short_outfile = None
        too_short_filter = TooShortReadFilter(options.minimum_length,
                                              too_short_outfile)
        writers.append(too_short_filter)
    too_long_outfile = None  # too long reads go here
    too_long_filter = None
    if options.maximum_length < sys.maxsize:
        if options.too_long_output is not None:
            too_long_outfile = xopen(options.too_long_output, 'w')
        else:
            too_long_outfile = None
        too_long_filter = TooLongReadFilter(options.maximum_length,
                                            too_long_outfile)
        writers.append(too_long_filter)

    demultiplexer = None
    if options.output is not None and '{name}' in options.output:
        if options.discard_trimmed:
            parser.error("Do not use --discard-trimmed when demultiplexing.")
        if input_paired_filename:
            parser.error(
                "Demultiplexing not supported for paired-end files, yet.")
        untrimmed = options.output.format(name='unknown')
        if options.untrimmed_output:
            untrimmed = options.untrimmed_output
        if options.discard_untrimmed:
            untrimmed = None
        demultiplexer = Demultiplexer(options.output, untrimmed)
        writers.append(demultiplexer)
        trimmed_outfile, untrimmed_outfile = None, None
        trimmed_paired_outfile, untrimmed_paired_outfile = None, None
    else:
        trimmed_outfile, untrimmed_outfile = trimmed_and_untrimmed_files(
            default_outfile, options.output, options.untrimmed_output,
            options.discard_trimmed, options.discard_untrimmed)

        trimmed_paired_outfile, untrimmed_paired_outfile = trimmed_and_untrimmed_files(
            None,  # applies when not trimming paired-end data
            options.paired_output,
            options.untrimmed_paired_output,
            options.discard_trimmed,
            options.discard_untrimmed)

        writer = ProcessedReadWriter(trimmed_outfile, trimmed_paired_outfile,
                                     untrimmed_outfile,
                                     untrimmed_paired_outfile)
        writers.append(writer)

    if options.maq:
        options.colorspace = True
        options.double_encode = True
        options.trim_primer = True
        options.strip_suffix.append('_F3')
        options.suffix = "/1"
    if options.zero_cap is None:
        options.zero_cap = options.colorspace
    if options.trim_primer and not options.colorspace:
        parser.error("Trimming the primer makes only sense in colorspace.")
    if options.double_encode and not options.colorspace:
        parser.error("Double-encoding makes only sense in colorspace.")
    if options.anywhere and options.colorspace:
        parser.error(
            "Using --anywhere with colorspace reads is currently not supported (if you think this may be useful, contact the author)."
        )
    if not (0 <= options.error_rate <= 1.):
        parser.error("The maximum error rate must be between 0 and 1.")
    if options.overlap < 1:
        parser.error("The overlap must be at least 1.")

    if options.rest_file is not None:
        options.rest_file = xopen(options.rest_file, 'w')
        rest_writer = RestFileWriter(options.rest_file)
    else:
        rest_writer = None
    if options.info_file is not None:
        options.info_file = xopen(options.info_file, 'w')
    if options.wildcard_file is not None:
        options.wildcard_file = xopen(options.wildcard_file, 'w')

    if options.colorspace:
        if options.match_read_wildcards:
            parser.error('IUPAC wildcards not supported in colorspace')
        options.match_adapter_wildcards = False
    adapters = []
    ADAPTER_CLASS = ColorspaceAdapter if options.colorspace else Adapter

    try:
        for name, seq, where in gather_adapters(options.adapters,
                                                options.anywhere,
                                                options.front):
            if not seq:
                parser.error("The adapter sequence is empty")
            if not options.indels and where not in (PREFIX, SUFFIX):
                parser.error(
                    "Not allowing indels is currently supported only for anchored 5' and 3' adapters."
                )
            adapter = ADAPTER_CLASS(seq,
                                    where,
                                    options.error_rate,
                                    options.overlap,
                                    options.match_read_wildcards,
                                    options.match_adapter_wildcards,
                                    name=name,
                                    indels=options.indels)
            adapters.append(adapter)
    except IOError as e:
        if e.errno == errno.ENOENT:
            print("Error:", e, file=sys.stderr)
            sys.exit(1)
        raise

    if not adapters and options.quality_cutoff == 0 and options.cut == 0 and \
      options.minimum_length == 0 and options.maximum_length == sys.maxsize:
        parser.error("You need to provide at least one adapter sequence.")

    if input_paired_filename:
        reader = seqio.PairedSequenceReader(input_filename,
                                            input_paired_filename,
                                            colorspace=options.colorspace,
                                            fileformat=options.format)
    else:
        reader = read_sequences(input_filename,
                                quality_filename,
                                colorspace=options.colorspace,
                                fileformat=options.format)

    # Create the processing pipeline as a list of "modifiers".
    modifiers = []
    if options.cut:
        if len(options.cut) > 2:
            parser.error("You cannot remove bases from more than two ends.")
        if len(options.cut) == 2 and options.cut[0] * options.cut[1] > 0:
            parser.error("You cannot remove bases from the same end twice.")
        for cut in options.cut:
            if cut != 0:
                modifiers.append(UnconditionalCutter(cut))

    if options.quality_cutoff > 0:
        modifiers.append(
            QualityTrimmer(options.quality_cutoff, options.quality_base))
    if adapters:
        adapter_cutter = AdapterCutter(adapters, options.times,
                                       options.wildcard_file,
                                       options.info_file, rest_writer,
                                       options.action)
        modifiers.append(adapter_cutter)
    else:
        adapter_cutter = None
    if options.length_tag:
        modifiers.append(LengthTagModifier(options.length_tag))
    if options.strip_f3:
        options.strip_suffix.append('_F3')
    for suffix in options.strip_suffix:
        modifiers.append(SuffixRemover(suffix))
    if options.prefix or options.suffix:
        modifiers.append(PrefixSuffixAdder(options.prefix, options.suffix))
    if options.double_encode:
        modifiers.append(DoubleEncoder())
    if options.zero_cap and reader.delivers_qualities:
        modifiers.append(ZeroCapper(quality_base=options.quality_base))
    if options.trim_primer:
        modifiers.append(PrimerTrimmer)

    start_time = time.clock()
    try:
        if input_paired_filename:
            stats = process_paired_reads(reader, modifiers, writers)
        else:
            stats = process_single_reads(reader, modifiers, writers)
    except KeyboardInterrupt as e:
        print("Interrupted", file=sys.stderr)
        sys.exit(1)
    except IOError as e:
        if e.errno == errno.EPIPE:
            sys.exit(1)
        raise
    except seqio.FormatError as e:
        print("Error:", e, file=sys.stderr)
        sys.exit(1)

    # close open files
    for f in [
            trimmed_outfile, untrimmed_outfile, trimmed_paired_outfile,
            untrimmed_paired_outfile, options.rest_file, options.wildcard_file,
            options.info_file, too_short_outfile, too_long_outfile,
            options.info_file, demultiplexer
    ]:
        if f is not None and f is not sys.stdin and f is not sys.stdout:
            f.close()

    if not options.quiet:
        # send statistics to stderr if result was sent to stdout
        stat_file = sys.stderr if options.output is None else None
        print_statistics(adapters,
                         time.clock() - start_time,
                         stats,
                         options.action,
                         adapter_cutter.reads_matched if adapter_cutter else 0,
                         options.error_rate,
                         too_short_filter.too_short if too_short_filter else 0,
                         too_long_filter.too_long if too_long_filter else 0,
                         cmdlineargs,
                         file=stat_file)