PyamilySeq 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

PyamilySeq/Cluster_Summary.py

@@ -0,0 +1,163 @@
+import argparse
+from collections import OrderedDict
+from collections import defaultdict
+
+try:
+    from .constants import *
+    from .utils import *
+except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
+    from constants import *
+    from utils import *
+
+
+def categorise_percentage(percent):
+    """Categorise the percentage of genomes with multicopy genes."""
+    if 20 <= percent < 40:
+        return "20-40%"
+    elif 40 <= percent < 60:
+        return "40-60%"
+    elif 60 <= percent < 80:
+        return "60-80%"
+    elif 80 <= percent < 95:
+        return "80-95%"
+    elif 95 <= percent < 99:
+        return "95-99%"
+    elif 99 <= percent <= 100:
+        return "99-100%"
+    return None
+
+# Read cd-hit .clstr file and extract information
+def read_cd_hit_output(clustering_output):
+    clusters = OrderedDict()
+
+    with open(clustering_output, 'r') as f:
+        current_cluster_id = None
+
+        for line in f:
+            line = line.strip()
+            if line.startswith(">Cluster"):
+                current_cluster_id = line.split(' ')[1]
+                clusters[current_cluster_id] = []
+            elif line and current_cluster_id is not None:
+                parts = line.split('\t')
+                if len(parts) > 1:
+                    clustered_info = parts[1]
+                    length = clustered_info.split(',')[0]
+                    length = int(''.join(c for c in length if c.isdigit()))
+                    clustered_header = clustered_info.split('>')[1].split('...')[0]
+                    clustered_header = '>' + clustered_header
+
+                    if 'at ' in clustered_info and '%' in clustered_info.split('at ')[-1]:
+                        percent_identity = extract_identity(clustered_info)
+                    elif line.endswith('*'):
+                        percent_identity = 100.0
+                    else:
+                        raise ValueError("Percent identity not found in the string.")
+
+                    clusters[current_cluster_id].append({
+                        'header': clustered_header,
+                        'length': length,
+                        'percent_identity': percent_identity
+                    })
+
+    return clusters
+
+
+# Summarise the information for each cluster
+def summarise_clusters(options,clusters, output):
+    multicopy_groups = defaultdict(int)  # Counter for groups with multicopy genes
+
+    with open(output, 'w') as out_f:
+        out_f.write("Cluster_ID\tNum_Sequences\tAvg_Length\tLength_Range\tAvg_Identity\tIdentity_Range\n")
+
+        for cluster_id, seqs in clusters.items():
+            num_seqs = len(seqs)
+            lengths = [seq['length'] for seq in seqs]
+            identities = [seq['percent_identity'] for seq in seqs]
+
+            avg_length = sum(lengths) / num_seqs if num_seqs > 0 else 0
+            length_range = f"{min(lengths)}-{max(lengths)}" if num_seqs > 0 else "N/A"
+
+            avg_identity = sum(identities) / num_seqs if num_seqs > 0 else 0
+            identity_range = f"{min(identities):.2f}-{max(identities):.2f}" if num_seqs > 0 else "N/A"
+
+            out_f.write(
+                f"{cluster_id}\t{num_seqs}\t{avg_length:.2f}\t{length_range}\t{avg_identity:.2f}\t{identity_range}\n")
+
+            # Count genomes with more than one gene
+            genome_to_gene_count = defaultdict(int)
+            for seq in seqs:
+                genome = seq['header'].split('|')[0].replace('>','')
+                genome_to_gene_count[genome] += 1
+
+            num_genomes_with_multiple_genes = sum(1 for count in genome_to_gene_count.values() if count > 1)
+
+            # Calculate the percentage of genomes with multicopy genes
+
+            multicopy_percentage = (num_genomes_with_multiple_genes / options.genome_num) * 100
+            category = categorise_percentage(multicopy_percentage)
+            if category:
+                multicopy_groups[category] += 1
+
+        # Define the order of categories for printout
+        category_order = ["20-40%", "40-60%", "60-80%", "80-95%", "95-99%", "99-100%"]
+
+        # Print the number of clusters with multicopy genes in each percentage range, in the correct order
+        for category in category_order:
+            print(f"Number of clusters with multicopy genes in {category} range: {multicopy_groups[category]}")
+
+
+# Main function to parse arguments and run the analysis
+def main():
+    parser = argparse.ArgumentParser(description='PyamilySeq ' + PyamilySeq_Version + ': Cluster-Summary - A tool to summarise CD-HIT clustering files.')
+    ### Required Arguments
+    required = parser.add_argument_group('Required Parameters')
+    required.add_argument('-input_clstr', action="store", dest="input_clstr",
+                          help='Input CD-HIT .clstr file',
+                          required=True)
+    required.add_argument('-output', action="store", dest="output",
+                          help="Output TSV file to store cluster summaries - Will add '.tsv' if not provided by user",
+                          required=True)
+    required.add_argument('-genome_num', action='store', dest='genome_num', type=int,
+                          help='The total number of genomes must be provide',
+                          required=True)
+    #required.add_argument("-clustering_format", action="store", dest="clustering_format", choices=['CD-HIT','TSV','CSV'],
+    #                      help="Clustering format to use: CD-HIT or TSV (MMseqs2, BLAST, DIAMOND) / CSV edge-list file (Node1\tNode2).",
+    #                      required=True)
+
+    optional = parser.add_argument_group('Optional Arguments')
+    optional.add_argument('-output_dir', action="store", dest="output_dir",
+                          help='Default: Same as input file',
+                          required=False)
+
+    misc = parser.add_argument_group("Misc Parameters")
+    misc.add_argument("-verbose", action="store_true", dest="verbose",
+                      help="Print verbose output.",
+                      required=False)
+    misc.add_argument("-v", "--version", action="version",
+                      version=f"PyamilySeq: Group-Summary version {PyamilySeq_Version} - Exiting",
+                      help="Print out version number and exit")
+
+
+    options = parser.parse_args()
+    print("Running PyamilySeq " + PyamilySeq_Version+ ": Group-Summary ")
+
+    ### File handling
+    options.input_clstr = fix_path(options.input_clstr)
+    if options.output_dir is None:
+        options.output_dir = os.path.dirname(os.path.abspath(options.input_clstr))
+    output_path = os.path.abspath(options.output_dir)
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+    output_name = options.output
+    if not output_name.endswith('.tsv'):
+        output_name += '.tsv'
+    output_file_path = os.path.join(output_path, output_name)
+    ###
+
+    clusters = read_cd_hit_output(options.input_clstr)
+    summarise_clusters(options,clusters, output_file_path)
+
+
+if __name__ == "__main__":
+    main()

PyamilySeq/Group_Extractor.py

@@ -0,0 +1,83 @@
+import argparse
+import os
+import csv
+
+
+def parse_fasta(fasta_file):
+    """
+    Parses a FASTA file and returns a dictionary of gene IDs and sequences.
+    """
+    sequences = {}
+    with open(fasta_file, 'r') as f:
+        gene_id = None
+        sequence = []
+        for line in f:
+            line = line.strip()
+            if line.startswith(">"):
+                if gene_id:  # Save the previous gene
+                    sequences[gene_id] = ''.join(sequence)
+                gene_id = line[1:].split()[0].split('|')[1].replace('ENSB_','')  # Extract the gene ID after ">"
+                sequence = []
+            else:
+                sequence.append(line)
+        if gene_id:  # Save the last gene
+            sequences[gene_id] = ''.join(sequence)
+    return sequences
+
+
+def parse_csv(csv_file):
+    """
+    Parses a CSV file to extract group IDs and gene IDs (skipping the first line).
+    """
+    groups = {}
+    with open(csv_file, 'r') as f:
+        reader = csv.reader(f, delimiter=',')  # Assuming tab-delimited CSV
+        next(reader)  # Skip the first line
+        for row in reader:
+            group_id = row[0]
+            gene_ids = row[14:]  # Read from column 14 onward
+            gene_ids = [gene.strip() for genes in gene_ids for gene in genes.split(';') if
+                        gene.strip()]  # Flatten and clean
+            groups[group_id] = gene_ids
+    return groups
+
+
+def write_group_fastas(groups, sequences, output_dir):
+    """
+    Writes individual FASTA files for each group with the relevant sequences.
+    """
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for group_id, gene_ids in groups.items():
+        group_file = os.path.join(output_dir, f"{group_id}.fasta")
+        with open(group_file, 'w') as f:
+            for gene_id in gene_ids:
+                if gene_id in sequences:
+                    f.write(f">{gene_id}\n{sequences[gene_id]}\n")
+                else:
+                    print(f"Warning: Gene ID {gene_id} not found in FASTA file.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Process FASTA and CSV files to create grouped FASTA outputs.")
+    parser.add_argument("-fasta", required=True, help="Input FASTA file containing gene sequences.")
+    parser.add_argument("-csv", required=True, help="Input CSV file containing group and gene information.")
+    parser.add_argument("-output_dir", required=True, help="Directory to save the grouped FASTA files.")
+
+    args = parser.parse_args()
+
+    # Parse the input files
+    print("Parsing FASTA file...")
+    sequences = parse_fasta(args.fasta)
+    print("Parsing CSV file...")
+    groups = parse_csv(args.csv)
+
+    # Write the grouped FASTA files
+    print("Writing grouped FASTA files...")
+    write_group_fastas(groups, sequences, args.output_dir)
+    print("Process completed successfully.")
+
+
+if __name__ == "__main__":
+    main()

PyamilySeq/Group_Sizes.py

@@ -0,0 +1,87 @@
+import argparse
+import os
+import csv
+
+
+def parse_fasta_stats(fasta_file):
+    """
+    Parses a FASTA file and calculates sequence statistics.
+    """
+    lengths = []
+    with open(fasta_file, 'r') as f:
+        sequence = []
+        for line in f:
+            line = line.strip()
+            if line.startswith(">"):
+                if sequence:  # Save the previous sequence length
+                    lengths.append(len(''.join(sequence)))
+                sequence = []  # Reset for the next sequence
+            else:
+                sequence.append(line)
+        if sequence:  # Save the last sequence length
+            lengths.append(len(''.join(sequence)))
+
+    # Calculate statistics
+    num_sequences = len(lengths)
+    if num_sequences > 0:
+        avg_length = sum(lengths) / num_sequences
+        min_length = min(lengths)
+        max_length = max(lengths)
+        length_diff = max_length - min_length
+        percent_diff = (length_diff / min_length * 100) if min_length > 0 else 0
+    else:
+        avg_length = min_length = max_length = length_diff = percent_diff = 0
+
+    return {
+        "num_sequences": num_sequences,
+        "min_length": min_length,
+        "max_length": max_length,
+        "avg_length": avg_length,
+        "length_diff": length_diff,
+        "percent_diff": percent_diff
+    }
+
+
+def process_fasta_directory(input_dir, output_csv):
+    """
+    Processes a directory of FASTA files and writes statistics to a CSV file.
+    """
+    results = []
+    for filename in os.listdir(input_dir):
+        if filename.endswith(".fasta"):
+            file_path = os.path.join(input_dir, filename)
+            stats = parse_fasta_stats(file_path)
+            results.append({
+                "file_name": filename,
+                "num_sequences": stats["num_sequences"],
+                "min_length": stats["min_length"],
+                "max_length": stats["max_length"],
+                "avg_length": stats["avg_length"],
+                "length_diff": stats["length_diff"],
+                "percent_diff": stats["percent_diff"]
+            })
+
+    # Write results to a CSV file
+    with open(output_csv, 'w', newline='') as csvfile:
+        fieldnames = ["file_name", "num_sequences", "min_length", "max_length", "avg_length", "length_diff",
+                      "percent_diff"]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(results)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Summarize sequence statistics for a directory of FASTA files.")
+    parser.add_argument("-input_dir", required=True, help="Directory containing FASTA files.")
+    parser.add_argument("-output_csv", required=True, help="Output CSV file to save statistics.")
+
+    args = parser.parse_args()
+
+    # Process the directory of FASTA files
+    print("Processing FASTA files...")
+    process_fasta_directory(args.input_dir, args.output_csv)
+    print(f"Statistics saved to {args.output_csv}")
+
+
+if __name__ == "__main__":
+    main()