import argparse as arg

from smartdada2.reader import reader


def getPairedFiles(main_fastq: str, output_f: str, output_r: str):
    """If paired end sequencing was performed get
    two files containing reverse and forward sequences.

    Args:
        main_fastq (str): one FASTq formatted file containing all
        reads
        output_f (str): output file path for forward sequences
        output_r (str): output file path for reverse sequences

    Returns:
        files: two fastq files will be written containing
        forward and reverse reads separately.
    """
    # make sure input is of right type
    if not isinstance(main_fastq, str):
        raise TypeError("must be a file path of type string")

    # read in data
    fqe = reader.FastqReader(main_fastq)

    # make sure data is correct type
    if not isinstance(fqe, reader.FastqReader):
        raise TypeError("must be of FastqEntry type")

    # get forward reads in list format
    forward = []
    for reads in fqe.get_forward_reads():
        forward.extend((reads.header, reads.seq, "+", reads.scores))

    # write forward file
    with open(output_f, "+w") as f:
        for line in forward:
            line = str(line) + "\n"
            f.write(line)

    # get reverse reads in list format
    reverse = []
    for reads in fqe.get_reverse_reads():
        reverse.extend((reads.header, reads.seq, "+", reads.scores))

    # write reverse file
    with open(output_r, "+w") as f:
        for line in reverse:
            line = str(line) + "\n"
            f.write(line)

    return None


# created parser to run through terminal
def main():
    parser = arg.ArgumentParser(
        description="This script will separate forward and reverse "
        + "reads for either paired or single end sequencing"
    )

    parser.add_argument(
        "--fq",
        "-fastq",
        type=str,
        required=True,
        help="file path to fastq files",
    )

    parser.add_argument(
        "--of_f",
        "-output_file_forward",
        type=str,
        required=True,
        help="output file path for forward sequences",
    )

    parser.add_argument(
        "--of_r",
        "-output_file_reverse",
        type=str,
        required=True,
        help="output file path for reverse sequences",
    )

    args = parser.parse_args()

    getPairedFiles(args.fq, args.of_f, args.of_r)

    exit()


if __name__ == "__main__":
    main()

import argparse as arg

from smartdada2.reader import reader


def subsample(input_fp: str, subsample: int, output_fp: str):
    """Takes one FASTQ file and outputs subsets of the reads.

    Args:
        input_fp (str): FASTQ file path
        subsample (int): number of reads in subset
        output_fp (str): FASTQ file subset output path

    Returns:
        A fastq formatted file containing a subset of the original
        reads.
    """
    # make sure input is of right type
    if not isinstance(input_fp, str):
        raise TypeError("must be a file path of type string")
    if not isinstance(subsample, int):
        raise TypeError("subsampling must be of integer type")
    if not isinstance(output_fp, str):
        raise TypeError("must be a file path of type string")

    # read in data
    fqe = reader.FastqReader(input_fp)

    # make sure data is correct type
    if not isinstance(fqe, reader.FastqReader):
        raise TypeError("must be of FastqEntry type")

    # perform reservoir sampling
    samples = fqe.reservoir_sampling(n_samples=subsample, seed=5)

    # create list of samples
    sample_list = []
    for sample in samples:
        sample_list.extend((sample.header, sample.seq, "+", sample.scores))

    # write into a fastq formatted file
    with open(output_fp, "+w") as f:
        for line in sample_list:
            line = str(line) + "\n"
            f.write(line)

    return None


# created parser to run through terminal
def main():
    parser = arg.ArgumentParser(
        description="This script will take a fastq formatted file"
        + "and output a subset of it"
    )

    parser.add_argument(
        "--fq",
        "-fastq",
        type=str,
        required=True,
        help="file path to fastq files",
    )

    parser.add_argument(
        "--n", "-n_sample", type=int, required=True, help="Number of samples in subset"
    )

    parser.add_argument(
        "--of", "-output_file", type=str, required=True, help="output file path"
    )

    args = parser.parse_args()

    subsample(args.fq, args.n, args.of)

    exit()


if __name__ == "__main__":
    main()

import argparse as arg
import warnings

import GetMaxEE as GME
import GetTrimParameters as GTP

from smartdada2.reader import reader


def main():
    parser = arg.ArgumentParser(
        description="This script will output a dataframe containing"
        + "trimming information read length, average expected error by"
        + "position and the number of reads below and over a threshold"
    )

    parser.add_argument(
        "--fq",
        "-fastq",
        type=str,
        required=True,
        help="file path to fastq files",
    )
    parser.add_argument(
        "--t_of",
        "-trim_output_file",
        type=str,
        required=False,
        help="name of the output file containing trim information",
        default="parameter_info.tsv",
    )
    parser.add_argument(
        "--th",
        "-threshold",
        type=int,
        required=False,
        help="Phred score threshold for obvious trimming",
        default=30,
    )
    parser.add_argument(
        "--o_mtp",
        "-obvs_max_trim_percentage",
        type=float,
        required=False,
        help="max percent of the length of the original trim to be"
        + "trimmed on either end of the read in obvious trimming",
        default=0.1,
    )
    parser.add_argument(
        "--a_mtp",
        "-additional_max_trim_percentage",
        type=float,
        required=False,
        help="when performing further trimming the max percentage of"
        + "the read to be trimmed at either end",
        default=0.2,
    )
    parser.add_argument(
        "--EE_of",
        "-EE_output_file",
        type=str,
        required=False,
        help="name of output file containing sum of EE information",
        default="SumEEInfo.tsv",
    )

    args = parser.parse_args()

    # ensure o_mtp is less than a_mtp
    if args.o_mtp > args.a_mtp:
        warnings.warn(
            "max percentage of trimming done in obvious trimming is larger"
            + "than the max in following steps which is not recommended"
        )

    # read in data
    fqe = reader.FastqReader(args.fq)

    # get average scores per position
    avg_scores_df = fqe.get_average_score()
    avg_scores_list = avg_scores_df["AverageQualityScore"].values.tolist()

    # perform obvious trimming
    left, right = GTP.trim_ends_less_than_threshold(
        avg_scores_list, args.th, args.o_mtp
    )

    # get average EE by position for different read sizes
    EE_by_size_df = GTP.read_size_by_avg_EE(fqe, left, right, args.a_mtp)

    # get dataframe containing the sum of the expected error per sequence
    sumEE = GME.read_size_by_maxEE(fqe, left, right)

    # convert final dataframes to TSV
    EE_by_size_df.to_csv(args.t_of, sep="\t", index=False)
    sumEE.to_csv(args.EE_of, sep="\t", index=False)

    exit()


if __name__ == "__main__":
    main()

shell:
    "python smartdada2/GetPairedendFiles.py --fq {input.fq} --of_f {output.forward} --of_r {output.rev}"

shell:
    "python smartdada2/GetSubsamples.py --fq {input} --n {params.n} --of {output}"

shell:
    "python smartdada2/main.py --fq {input} --t_of {output.TrimInfo} --th {params.threshold} --o_mtp {params.o_mtp} --a_mtp {params.a_mtp} --EE_of {output.SumEEInfo}"

shell:
    "Rscript " + "smartdada2/R_scripts/vizualize.R --trim_file {input.TrimInfo} --sumEE_file {input.sumEEInfo} --output_file {input.output_file}"

shell:
    "Rscript " + "smartdada2/R_scripts/wrapper_RunRender.R --trim_file {input.TrimInfo} --sumEE_file {input.sumEEInfo} --output_file {input.output_file}"