comparison validate_fasta.py @ 9:3bd420ec162d draft

planemo upload for repository https://github.com/usegalaxy-au/tools-au commit 7726c3cba165bdc8fc6366ec0ce6596e55657468

8:ca90d17ff51b

import re
import sys
import argparse
from typing import List


class Fasta:
    def __init__(self, header_str: str, seq_str: str):
        self.header = header_str

class FastaValidator:
    def __init__(
            self,
            fasta_list: List[Fasta],
            min_length=None,
            max_length=None):
        self.min_length = min_length
        self.max_length = max_length
        self.fasta_list = fasta_list
        self.iupac_characters = {
            'A', 'B', 'C', 'D', 'E', 'F', 'G',
            'H', 'I', 'K', 'L', 'M', 'N', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
            'Y', 'Z', '-'
        }

    def validate(self):
        """Perform FASTA validation."""
        self.validate_num_seqs()
        self.validate_length()
        self.validate_alphabet()

        # not checking for 'X' nucleotides at the moment.
        # alphafold can throw an error if it doesn't like it.
        # self.validate_x()

    def validate_num_seqs(self) -> None:
        """Assert that only one sequence has been provided."""
        if len(self.fasta_list) > 1:
            sys.stderr.write(
                'WARNING: More than 1 sequence detected.'
                ' Using first FASTA sequence as input.\n')
            self.fasta_list = self.fasta_list[:1]
        elif len(self.fasta_list) == 0:
            raise ValueError(
                'Error encountered validating FASTA:\n'
                ' input file has no FASTA sequences')

    def validate_length(self):
        """Confirm whether sequence length is valid."""
        fasta = self.fasta_list[0]
        if self.min_length:

        args = parse_args()
        fas = FastaLoader(args.input)

        # validate
        fv = FastaValidator(
            fas.fastas,
            min_length=args.min_length,
            max_length=args.max_length,
        )
        fv.validate()

        # write cleaned version
        fw = FastaWriter()
        fw.write(fas.fastas[0])

    except ValueError as exc:
        sys.stderr.write(f"{exc}\n\n")
        raise exc

        dest='max_length',
        help="Maximum length of input protein sequence (AA)",
        default=None,
        type=int,
    )
    return parser.parse_args()


if __name__ == '__main__':
    main()

9:3bd420ec162d

import re
import sys
import argparse
from typing import List

MULTIMER_MAX_SEQUENCE_COUNT = 10


class Fasta:
    def __init__(self, header_str: str, seq_str: str):
        self.header = header_str

class FastaValidator:
    def __init__(
            self,
            min_length=None,
            max_length=None,
            multiple=False):
        self.multiple = multiple
        self.min_length = min_length
        self.max_length = max_length
        self.iupac_characters = {
            'A', 'B', 'C', 'D', 'E', 'F', 'G',
            'H', 'I', 'K', 'L', 'M', 'N', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
            'Y', 'Z', '-'
        }

    def validate(self, fasta_list: List[Fasta]):
        """Perform FASTA validation."""
        self.fasta_list = fasta_list
        self.validate_num_seqs()
        self.validate_length()
        self.validate_alphabet()
        # not checking for 'X' nucleotides at the moment.
        # alphafold can throw an error if it doesn't like it.
        # self.validate_x()
        return self.fasta_list

    def validate_num_seqs(self) -> None:
        """Assert that only one sequence has been provided."""
        fasta_count = len(self.fasta_list)

        if self.multiple:
            if fasta_count < 2:
                raise ValueError(
                    'Error encountered validating FASTA:\n'
                    'Multimer mode requires multiple input sequence.'
                    f' Only {fasta_count} sequences were detected in'
                    ' the provided file.')
                self.fasta_list = self.fasta_list

            elif fasta_count > MULTIMER_MAX_SEQUENCE_COUNT:
                sys.stderr.write(
                    f'WARNING: detected {fasta_count} sequences but the'
                    f' maximum allowed is {MULTIMER_MAX_SEQUENCE_COUNT}'
                    ' sequences. The last'
                    f' {fasta_count - MULTIMER_MAX_SEQUENCE_COUNT} sequence(s)'
                    ' have been discarded.\n')
                self.fasta_list = self.fasta_list[:MULTIMER_MAX_SEQUENCE_COUNT]
        else:
            if fasta_count > 1:
                sys.stderr.write(
                    'WARNING: More than 1 sequence detected.'
                    ' Using first FASTA sequence as input.\n')
                self.fasta_list = self.fasta_list[:1]

            elif len(self.fasta_list) == 0:
                raise ValueError(
                    'Error encountered validating FASTA:\n'
                    ' no FASTA sequences detected in input file.')

    def validate_length(self):
        """Confirm whether sequence length is valid."""
        fasta = self.fasta_list[0]
        if self.min_length:

        args = parse_args()
        fas = FastaLoader(args.input)

        # validate
        fv = FastaValidator(
            min_length=args.min_length,
            max_length=args.max_length,
            multiple=args.multimer,
        )
        clean_fastas = fv.validate(fas.fastas)

        # write clean data
        fw = FastaWriter()
        for fas in clean_fastas:
            fw.write(fas)

    except ValueError as exc:
        sys.stderr.write(f"{exc}\n\n")
        raise exc

        dest='max_length',
        help="Maximum length of input protein sequence (AA)",
        default=None,
        type=int,
    )
    parser.add_argument(
        "--multimer",
        action='store_true',
        help="Require multiple input sequences",
    )
    return parser.parse_args()


if __name__ == '__main__':
    main()