pg-sui 0.2.0__py3-none-any.whl → 1.6.14.dev9__py3-none-any.whl

pgsui/pg_sui.py

@@ -1,261 +0,0 @@
-#!/usr/bin/env python
-
-# Standard library imports
-import argparse
-import sys
-
-import numpy as np
-import pandas as pd
-
-from sklearn_genetic.space import Continuous, Categorical, Integer
-
-from snpio import GenotypeData
-from snpio import Plotting
-from pgsui import *
-
-
-def main():
-    """Class instantiations and main package body"""
-
-    args = get_arguments()
-
-    if args.str and args.phylip:
-        sys.exit("Error: Only one file type can be specified")
-
-        # If VCF file is specified.
-    if args.str:
-        if not args.pop_ids and args.popmap is None:
-            raise TypeError("Either --pop_ids or --popmap must be specified\n")
-
-        if args.pop_ids:
-            print("\n--pop_ids was specified as column 2\n")
-        else:
-            print(
-                "\n--pop_ids was not specified; "
-                "using popmap file to get population IDs\n"
-            )
-
-        if args.onerow_perind:
-            print("\nUsing one row per individual...\n")
-        else:
-            print("\nUsing two rows per individual...\n")
-
-        if args.onerow_perind:
-            data = GenotypeData(
-                filename=args.str,
-                filetype="structure1row",
-                popmapfile=args.popmap,
-                guidetree=args.treefile,
-                qmatrix_iqtree=args.iqtree,
-                prefix=args.prefix,
-            )
-        else:
-            data = GenotypeData(
-                filename=args.str,
-                filetype="structure2row",
-                popmapfile=args.popmap,
-                guidetree=args.treefile,
-                qmatrix_iqtree=args.iqtree,
-                prefix=args.prefix,
-            )
-
-    if args.phylip:
-        if args.pop_ids or args.onerow_perind:
-            print(
-                "\nPhylip file was used with structure arguments; ignoring "
-                "structure file arguments\n"
-            )
-
-        if args.popmap is None:
-            raise TypeError("No popmap file supplied with PHYLIP file\n")
-
-        data = GenotypeData(
-            filename=args.phylip,
-            filetype="phylip",
-            popmapfile=args.popmap,
-            guidetree=args.treefile,
-            qmatrix_iqtree=args.iqtree,
-            siterates_iqtree=args.site_rate,
-            prefix=args.prefix,
-        )
-
-    data.missingness_reports(prefix=args.prefix, plot_format="png")
-
-    # For GridSearchCV. Generate parameters to sample from.
-    learning_rate = [float(10) ** x for x in np.arange(-4, -1)]
-    l1_penalty = [float(10) ** x for x in np.arange(-5, -1)]
-    l1_penalty.append(0.0)
-    l2_penalty = [float(10) ** x for x in np.arange(-5, -1)]
-    l2_penalty.append(0.0)
-    hidden_activation = ["elu", "relu"]
-    num_hidden_layers = [1, 2, 3]
-    hidden_layer_sizes = ["sqrt", "midpoint"]
-    n_components = [2, 3, 5, 10]
-    dropout_rate = [0.0, 0.2, 0.4]
-    # batch_size = [16, 32, 48, 64]
-    optimizer = ["adam", "sgd", "adagrad"]
-
-    # Some are commented out for testing purposes.
-    # grid_params = {
-    #     "learning_rate": learning_rate,
-    #     # "l1_penalty": l1_penalty,
-    #     # "l2_penalty": l2_penalty,
-    #     # "hidden_layer_sizes": hidden_layer_sizes,
-    #     "n_components": n_components,
-    #     # "dropout_rate": dropout_rate,
-    #     # # "optimizer": optimizer,
-    #     # "num_hidden_layers": num_hidden_layers,
-    #     # "hidden_activation": hidden_activation,
-    # }
-
-    imp = ImputeXGBoost(
-        data,
-        max_iter=3,
-        gridparams={"n_estimators": [100, 200]},
-        n_nearest_features=5,
-        # disable_progressbar=False,
-        # epochs=100,
-        # cv=3,
-        # column_subset=1.0,
-        # learning_rate=0.01,
-        # num_hidden_layers=1,
-        # hidden_layer_sizes="midpoint",
-        # verbose=10,
-        # dropout_rate=0.2,
-        # hidden_activation="relu",
-        # batch_size=32,
-        # l1_penalty=1e-6,
-        # l2_penalty=1e-6,
-        # # gridparams=grid_params,
-        # n_jobs=4,
-        # grid_iter=5,
-        # sim_strategy="nonrandom_weighted",
-        # sim_prop_missing=0.5,
-        # scoring_metric="precision_recall_macro",
-        # gridsearch_method="gridsearch",
-        # early_stop_gen=5,
-        # n_components=3,
-        # sample_weights={0: 1.0, 1: 0.0, 2: 1.0},
-        # sample_weights="auto",
-    )
-
-    gd_imp = imp.imputed
-
-    components, model = Plotting.run_pca(
-        data,
-        plot_format="png",
-        center=True,
-        scale=False,
-        prefix=args.prefix,
-        # n_axes=3,
-    )
-
-    components_imp, model_imp = Plotting.run_pca(
-        gd_imp,
-        plot_format="png",
-        center=True,
-        scale=False,
-        prefix=args.prefix + "_imputed",
-    )
-
-
-def get_arguments():
-    """[Parse command-line arguments. Imported with argparse]
-
-    Returns:
-        [argparse object]: [contains command-line arguments; accessed as method]
-    """
-
-    parser = argparse.ArgumentParser(
-        description="Machine learning missing data imputation and species delimitation",
-        add_help=False,
-    )
-
-    required_args = parser.add_argument_group("Required arguments")
-    filetype_args = parser.add_argument_group(
-        "File type arguments (choose only one)"
-    )
-    structure_args = parser.add_argument_group("Structure file arguments")
-    optional_args = parser.add_argument_group("Optional arguments")
-
-    # File Type arguments
-    filetype_args.add_argument(
-        "-s", "--str", type=str, required=False, help="Input structure file"
-    )
-    filetype_args.add_argument(
-        "-p", "--phylip", type=str, required=False, help="Input phylip file"
-    )
-
-    filetype_args.add_argument(
-        "-t",
-        "--treefile",
-        type=str,
-        required=False,
-        default=None,
-        help="Newick-formatted treefile",
-    )
-
-    filetype_args.add_argument(
-        "-i",
-        "--iqtree",
-        type=str,
-        required=False,
-        help=".iqtree output file containing Rate Matrix Q",
-    )
-
-    filetype_args.add_argument(
-        "--site_rate",
-        type=str,
-        required=False,
-        help="Specify site rate input file.",
-    )
-
-    # Structure Arguments
-    structure_args.add_argument(
-        "--onerow_perind",
-        default=False,
-        action="store_true",
-        help="Toggles on one row per individual option in structure file",
-    )
-    structure_args.add_argument(
-        "--pop_ids",
-        default=False,
-        required=False,
-        action="store_true",
-        help="Toggles on population ID column (2nd col) in structure file",
-    )
-
-    ## Optional Arguments
-    optional_args.add_argument(
-        "-m",
-        "--popmap",
-        type=str,
-        required=False,
-        default=None,
-        help="Two-column tab-separated population map file: inds\tpops. No header line",
-    )
-    optional_args.add_argument(
-        "--prefix",
-        type=str,
-        required=False,
-        default="imputer",
-        help="Prefix for output directory. Output directory will be '<prefix>_output'",
-    )
-
-    # Add help menu
-    optional_args.add_argument(
-        "-h", "--help", action="help", help="Displays this help menu"
-    )
-
-    # If no command-line arguments are called then exit and call help menu.
-    if len(sys.argv) == 1:
-        print("\nExiting because no command-line options were called.\n")
-        parser.print_help(sys.stderr)
-        sys.exit(1)
-
-    args = parser.parse_args()
-    return args
-
-
-if __name__ == "__main__":
-    main()

pgsui/utils/sequence_tools.py

@@ -1,407 +0,0 @@
-import re
-import sys
-from itertools import product
-from collections import Counter
-
-
-def blacklist_missing(loci, threshold, iupac=False):
-    blacklist = list()
-    for i in range(0, len(loci)):
-        alleles = expandLoci(loci[i], iupac=False)
-        c = Counter(alleles)
-        if float(c[-9] / sum(c.values())) > threshold:
-            blacklist.append(i)
-    return blacklist
-
-
-def blacklist_maf(loci, threshold, iupac=False):
-    blacklist = list()
-    for i in range(0, len(loci)):
-        alleles = expandLoci(loci[i], iupac=False)
-        c = Counter(alleles)
-        if len(c.keys()) <= 1:
-            blacklist.append(i)
-            continue
-        else:
-            minor_count = c.most_common(2)[1][1]
-            if float(minor_count / sum(c.values())) < threshold:
-                blacklist.append(i)
-    return blacklist
-
-
-def expandLoci(loc, iupac=False):
-    """List of genotypes in 0-1-2 format."""
-    ret = list()
-    for i in loc:
-        if not iupac:
-            ret.extend(expand012(i))
-        else:
-            ret.extent(get_iupac_caseless(i))
-    return ret
-
-
-def expand012(geno):
-    g = str(geno)
-    if g == "0":
-        return [0, 0]
-    elif g == "1":
-        return [0, 1]
-    elif g == "2":
-        return [1, 1]
-    else:
-        return [-9, -9]
-
-
-def remove_items(all_list, bad_list):
-    """Remove items from list using another list."""
-    # using list comprehension to perform the task
-    return [i for i in all_list if i not in bad_list]
-
-
-def count_alleles(l, vcf=False):
-    """Count how many total alleles there are.
-
-    Args:
-        l (List[str]): List of IUPAC or VCF-style (e.g. 0/1) genotypes.
-        vcf (bool, optional): Whether genotypes are VCF or STRUCTURE-style. Defaults to False.
-
-    Returns:
-        int: Total number of alleles in l.
-    """
-    all_items = list()
-    for i in l:
-        if vcf:
-            all_items.extend(i.split("/"))
-        else:
-            all_items.extend(get_iupac_caseless(i))
-    all_items = remove_items(all_items, ["-9", "-", "N", -9])
-    return len(set(all_items))
-
-
-def get_major_allele(l, num=None, vcf=False):
-    """Get most common alleles in list.
-
-    Args:
-        l (List[str]): List of genotypes for one sample.
-
-        num (int, optional): Number of elements to return. Defaults to None.
-
-        vcf (bool, optional): Alleles in VCF or STRUCTURE-style format. Defaults to False.
-
-    Returns:
-        list: Most common alleles in descending order.
-    """
-    all_items = list()
-    for i in l:
-        if vcf:
-            all_items.extend(i.split("/"))
-        else:
-            all_items.extend(get_iupac_caseless(i))
-
-    c = Counter(all_items)  # requires collections import
-
-    # List of tuples with [(allele, count), ...] in order of
-    # most to least common
-    rets = c.most_common(num)
-
-    # Returns two most common non-ambiguous bases
-    # Makes sure the least common base isn't N or -9
-    if vcf:
-        return [x[0] for x in rets if x[0] != "-9"]
-    else:
-        return [x[0] for x in rets if x[0] in ["A", "T", "G", "C"]]
-
-
-def get_iupac_caseless(char):
-    """Split IUPAC code to two primary characters, assuming diploidy.
-
-    Gives all non-valid ambiguities as N.
-
-    Args:
-        char (str): Base to expand into diploid list.
-
-    Returns:
-        List[str]: List of the two expanded alleles.
-    """
-    lower = False
-    if char.islower():
-        lower = True
-        char = char.upper()
-    iupac = {
-        "A": ["A", "A"],
-        "G": ["G", "G"],
-        "C": ["C", "C"],
-        "T": ["T", "T"],
-        "N": ["N", "N"],
-        "-": ["N", "N"],
-        "R": ["A", "G"],
-        "Y": ["C", "T"],
-        "S": ["G", "C"],
-        "W": ["A", "T"],
-        "K": ["G", "T"],
-        "M": ["A", "C"],
-        "B": ["N", "N"],
-        "D": ["N", "N"],
-        "H": ["N", "N"],
-        "V": ["N", "N"],
-    }
-    ret = iupac[char]
-    if lower:
-        ret = [c.lower() for c in ret]
-    return ret
-
-
-def get_iupac_full(char):
-    """Split IUPAC code to all possible primary characters.
-
-    Gives all ambiguities as "N".
-
-    Args:
-        char (str): Base to expaned into list.
-
-    Returns:
-        List[str]: List of the expanded alleles.
-    """
-    char = char.upper()
-    iupac = {
-        "A": ["A"],
-        "G": ["G"],
-        "C": ["C"],
-        "T": ["T"],
-        "N": ["A", "C", "T", "G"],
-        "-": ["A", "C", "T", "G"],
-        "R": ["A", "G"],
-        "Y": ["C", "T"],
-        "S": ["G", "C"],
-        "W": ["A", "T"],
-        "K": ["G", "T"],
-        "M": ["A", "C"],
-        "B": ["C", "G", "T"],
-        "D": ["A", "G", "T"],
-        "H": ["A", "C", "T"],
-        "V": ["A", "C", "G"],
-    }
-    ret = iupac[char]
-    return ret
-
-
-def expandAmbiquousDNA(sequence):
-    """Generator function to expand ambiguous sequences"""
-    for i in product(*[get_iupac_caseless(j) for j in sequence]):
-        yield ("".join(i))
-
-
-def get_revComp_caseless(char):
-    """Function to return reverse complement of a nucleotide, while preserving case."""
-    lower = False
-    if char.islower():
-        lower = True
-        char = char.upper()
-    d = {
-        "A": "T",
-        "G": "C",
-        "C": "G",
-        "T": "A",
-        "N": "N",
-        "-": "-",
-        "R": "Y",
-        "Y": "R",
-        "S": "S",
-        "W": "W",
-        "K": "M",
-        "M": "K",
-        "B": "V",
-        "D": "H",
-        "H": "D",
-        "V": "B",
-    }
-    ret = d[char]
-    if lower:
-        ret = ret.lower()
-    return ret
-
-
-def reverseComplement(seq):
-    """Function to reverse complement a sequence, with case preserved."""
-    comp = []
-    for i in (get_revComp_caseless(j) for j in seq):
-        comp.append(i)
-    return "".join(comp[::-1])
-
-
-def simplifySeq(seq):
-    """Function to simplify a sequence."""
-    temp = re.sub("[ACGT]", "", (seq).upper())
-    return temp.translate(str.maketrans("RYSWKMBDHV", "**********"))
-
-
-def seqCounter(seq):
-    """Returns dict of character counts"""
-    d = {}
-    d = {
-        "A": 0,
-        "N": 0,
-        "-": 0,
-        "C": 0,
-        "G": 0,
-        "T": 0,
-        "R": 0,
-        "Y": 0,
-        "S": 0,
-        "W": 0,
-        "K": 0,
-        "M": 0,
-        "B": 0,
-        "D": 0,
-        "H": 0,
-        "V": 0,
-    }
-    for c in seq:
-        if c in d:
-            d[c] += 1
-    d["VAR"] = (
-        d["R"]
-        + d["Y"]
-        + d["S"]
-        + d["W"]
-        + d["K"]
-        + d["M"]
-        + d["B"]
-        + d["D"]
-        + d["H"]
-        + d["V"]
-    )
-    return d
-
-
-def getFlankCounts(ref, x, y, dist):
-    """Get vars, gaps, and N counts for flanking regions of a substring."""
-    x2 = x - dist
-    if x2 < 0:
-        x2 = 0
-    y2 = y + dist
-    if y2 > len(ref):
-        y2 = len(ref)
-    flanks = ref[x2:x] + ref[y:y2]  # flanks = right + left flank
-    counts = seqCounterSimple(simplifySeq(flanks))
-    return counts
-
-
-def seqCounterSimple(seq):
-    """Get dict of character counts from a simplified consensus sequence."""
-    d = {}
-    d = {"N": 0, "-": 0, "*": 0}
-    for c in seq:
-        if c in d:
-            d[c] += 1
-    return d
-
-
-def gc_counts(string):
-    """Get GC content of a provided sequence."""
-    new = re.sub("[GCgc]", "#", string)
-    return sum(1 for c in new if c == "#")
-
-
-def mask_counts(string):
-    """Get counts of masked bases."""
-    return sum(1 for c in string if c.islower())
-
-
-def gc_content(string):
-    """Get GC content as proportion."""
-    new = re.sub("[GCgc]", "#", string)
-    count = sum(1 for c in new if c == "#")
-    return count / (len(string))
-
-
-def mask_content(string):
-    """Count number of lower case in a string."""
-    count = sum(1 for c in string if c.islower())
-    return count / (len(string))
-
-
-def seqSlidingWindowString(seq, shift, width):
-    """Generator to create sliding windows by slicing out substrings."""
-    seqlen = len(seq)
-    for i in range(0, seqlen, shift):
-        if i + width > seqlen:
-            j = seqlen
-        else:
-            j = i + width
-        yield seq[i:j]
-        if j == seqlen:
-            break
-
-
-def seqSlidingWindow(seq, shift, width):
-    """Generator to create sliding windows by slicing out substrings."""
-    seqlen = len(seq)
-    for i in range(0, seqlen, shift):
-        if i + width > seqlen:
-            j = seqlen
-        else:
-            j = i + width
-        yield [seq[i:j], i, j]
-        if j == seqlen:
-            break
-
-
-def stringSubstitute(s, pos, c):
-    """Fast way to replace single char in string.
-
-    This way is a lot faster than doing it by making a list and subst in list.
-    """
-    return s[:pos] + c + s[pos + 1 :]
-
-
-def listToSortUniqueString(l):
-    """Get sorted unique string from list of chars.
-
-    Args:
-        l (List[str]): List of characters.
-
-    Returns:
-        List[str]: Sorted unique strings from list.
-    """
-    sl = sorted(set(l))
-    return str("".join(sl))
-
-
-def n_lower_chars(string):
-    """Count number of lower case in a string."""
-    return sum(1 for c in string if c.islower())
-
-
-def countSlidingWindow(seq, shift, width):
-    """Simplify a sequence to SNP, gaps, and Ns; get counts of sliding windows."""
-    seq_temp = re.sub("[ACGT]", "", seq.upper())
-    seq_norm = seq_temp.translate(str.maketrans("RYSWKMBDHV", "**********"))
-    for i in windowSub(seq_norm, shift, width):
-        # print(i)
-        window_seq = "".join(i)
-        seqCounterSimple(window_seq)
-
-
-class slidingWindowGenerator:
-    """Object for creating an iterable sliding window sampling."""
-
-    # Need to come back and comment better...
-    def __init__(self, seq, shift, width):
-        self.__seq = seq
-        self.__seqlen = len(self.__seq)
-        self.__shift = shift
-        self.__width = width
-        self.__i = 0
-
-    def __call__(self):
-        self.__seqlen
-        while self.__i < self.__seqlen:
-            # print("i is ", self.__i, " : Base is ", self.__seq[self.__i]) #debug print
-            if self.__i + self.__width > self.__seqlen:
-                j = self.__seqlen
-            else:
-                j = self.__i + self.__width
-            yield [self.__seq[self.__i : j], self.__i, j]
-            if j == self.__seqlen:
-                break