PyamilySeq 0.8.0__py3-none-any.whl → 0.9.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/Constants.py

@@ -1,2 +1,2 @@
-PyamilySeq_Version = 'v0.8.0'
+PyamilySeq_Version = 'v0.9.0'
 

PyamilySeq/Group_Splitter.py

@@ -1,3 +1,4 @@
+import collections
 import subprocess
 import os
 import argparse
@@ -21,6 +22,7 @@ def run_cd_hit(options, input_file, clustering_output, clustering_mode):
         '-T', str(options.clustering_threads),
         '-M', str(options.clustering_memory),
         '-d', "0",
+        '-g', "1",
         '-sc', "1",
         '-sf', "1"
     ]
@@ -29,24 +31,29 @@ def run_cd_hit(options, input_file, clustering_output, clustering_mode):
     else:
         subprocess.run(cdhit_command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
-
-def calculate_new_rep_seq(cluster_data):
+@profile
+def calculate_new_rep_seq(cluster_data, length_weight=1.0, identity_weight=1.0):
     total_length = sum(entry['length'] for entry in cluster_data)
     avg_length = total_length / len(cluster_data)
 
     total_identity = sum(entry['percent_identity'] for entry in cluster_data)
     avg_identity = total_identity / len(cluster_data)
 
+    # Normalize length and identity
+    max_length = max(entry['length'] for entry in cluster_data)
+    max_identity = 100  # Assuming percent_identity is out of 100
+
     # Calculate a score based on both length difference and percent identity
     def score(entry):
-        length_diff = abs(entry['length'] - avg_length)
-        identity_diff = abs(entry['percent_identity'] - avg_identity)
-        return length_diff + (100 - identity_diff)  # You can weight these differently
+        normalized_length_diff = abs(entry['length'] - avg_length) / max_length
+        normalized_identity_diff = abs(entry['percent_identity'] - avg_identity) / max_identity
+        return (length_weight * normalized_length_diff) + (identity_weight * (1 - normalized_identity_diff))
 
     rep_entry = min(cluster_data, key=score)
     return rep_entry
 
 
+
 def length_within_threshold(rep_length, length, len_diff):
     return abs(rep_length - length) / rep_length <= len_diff
 
@@ -58,16 +65,22 @@ def check_if_all_identical(clustered_sequences):
     return len(lengths) == 1 and len(perc_idents) == 1
 
 
-def read_fasta_groups(fasta_file):
+
+def read_fasta_groups(options):
     groups = defaultdict(list)
     genome_count = defaultdict(int)
     current_group = None
     current_sequence = []
 
-    with open(fasta_file, 'r') as f:
+    # Parse the list of specific group numbers if provided
+    selected_groups = None
+    if options.groups is not None:
+        selected_groups = [int(g.strip()) for g in options.groups.split(',')]
+
+    with open(options.input_fasta, 'r') as f:
         for line in f:
             if line.startswith('>'):
-                if current_group is not None:
+                if current_group is not None and (selected_groups is None or group_number in selected_groups):
                     groups[current_group].append((current_group_header, ''.join(current_sequence)))
 
                 current_group_header = line.strip()
@@ -75,6 +88,13 @@ def read_fasta_groups(fasta_file):
                 genome = current_group_header.split('|')[1]
                 current_sequence = []
                 genome_count[genome] += 1
+
+                # Only process if group matches the selected_groups or if no specific groups were provided
+                group_number = int(current_group.replace('>Group_', ''))  # Assuming format 'Group_n'
+                if selected_groups is not None and group_number not in selected_groups:
+                    current_group = None  # Skip this group
+                    continue
+
             else:
                 current_sequence.append(line.strip())
 
@@ -110,11 +130,12 @@ def read_cd_hit_output(clustering_output):
                     clustered_header = clustered_info.split('>')[1].split('...')[0]
                     clustered_header = '>' + clustered_header
 
-                    if 'at +' in clustered_info:
-                        percent_identity = float(clustered_info.split('at +/')[1].strip().replace('%', ''))
-
-                    if '*' in line:
+                    if 'at ' in clustered_info and '%' in clustered_info.split('at ')[-1]:
+                        percent_identity = extract_identity(line)
+                    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,
@@ -124,14 +145,16 @@ def read_cd_hit_output(clustering_output):
 
     return clusters
 
-
-def separate_groups(input_fasta, options, clustering_mode):
-    groups, genome_count = read_fasta_groups(input_fasta)
+@profile
+def separate_groups(options, clustering_mode):
+    groups, genome_count = read_fasta_groups(options)
 
     paralog_groups = defaultdict(int)  # To track number of paralog groups
 
-
     for group_header, sequences in groups.items():
+        if options.verbose:
+            print(f"\n###\nCurrent Group: {group_header.replace('>','')}\n")
+
         group_name = group_header.split('|')[0]  # Get the group part (e.g., '>Group_n')
 
         # Count genomes with more than one gene
@@ -141,106 +164,109 @@ def separate_groups(input_fasta, options, clustering_mode):
             genome_to_gene_count[genome] += 1
 
         num_genomes_with_multiple_genes = sum(1 for count in genome_to_gene_count.values() if count > 1)
-        total_genomes = len(genome_to_gene_count)
 
         # Check if the group meets the threshold for having paralogs
-        if total_genomes == 0 or (num_genomes_with_multiple_genes / total_genomes) * 100 < options.percent_threshold:
-            continue
+        if options.groups == None:
+            if (num_genomes_with_multiple_genes / options.genome_num) * 100 < options.group_threshold:
+                continue
+
 
         group_file_name = group_name.replace('>','')
 
-        temp_fasta = f"{options.output_dir}{group_file_name}.fasta"
+        temp_fasta = f"{options.output_dir}/{group_file_name}.fasta"
         write_fasta(sequences, temp_fasta)
 
         # Run cd-hit on the individual group
         clustering_output = f"{options.output_dir}/{group_file_name}_clustering"
+
         run_cd_hit(options, temp_fasta, clustering_output, clustering_mode)
 
         # Read the clustering results to find subgroups
         clustered_sequences = read_cd_hit_output(clustering_output + '.clstr')
 
-        # Detect if all sequences are identical in length and percentage identity
-        all_same = check_if_all_identical(clustered_sequences)
+        if len(clustered_sequences) == 1:
+            # Detect if all sequences are identical in length and percentage identity
+            all_same = check_if_all_identical(clustered_sequences)
 
         # **Global subgroup counter for the entire major group**
         subgroup_id = 0
-        remaining_sequences = sequences.copy() # Track unprocessed sequences
-        sequences_to_remove = []
+
 
         if not all_same:
-            while remaining_sequences:
-                # Track subgroups for this pass
-                subgroup_sequences = []
-                genome_seen = set()
-                sequences_found = False  # Track if any sequence was added
-
-                # Recalculate representative sequence dynamically based on remaining genes
-                rep = calculate_new_rep_seq(
-                    [entry for cluster in clustered_sequences.values() for entry in cluster if
-                     entry['header'] in (h for h, _ in remaining_sequences)]
-                )
-
-                # Find the sequence corresponding to rep['header'] from the list of sequences
-                rep_seq = next((seq for header, seq in sequences if header == rep['header']), None)
-
-                # Process each genome to select the best matching sequence
-                for genome in genome_to_gene_count:
-                    best_sequence = None
-                    best_score = -1  # Initialize with a very low similarity score
-
-                    # Iterate over each sequence in the remaining sequences for this genome
-                    for header, seq in remaining_sequences:
-                        genome_id = header.split('|')[1]
-
-                        if genome_id == genome:  # Ensure this sequence belongs to the current genome
-
-                            length = len(seq)
-                            if rep_seq == seq:
-                                perc_ident = 100.0
-                            else:
-                                perc_ident = calculate_similarity(rep_seq, seq)  # Define a function to calculate similarity
-
-                            # Calculate the length difference ratio (smaller ratio means closer length to the representative)
-                            length_diff_ratio = abs(rep['length'] - length) / rep['length']
-
-                            # Check if this sequence is more similar than the current best one
-                            if length_within_threshold(rep['length'], length,
-                                                       options.len_diff) and perc_ident >= options.pident:
-
-                                # Combine percentage identity and length difference into a single score
-                                # Here, you want a high identity and a small length difference
-                                # Adjust the weight of length difference and similarity according to your requirements
-                                score = perc_ident - (length_diff_ratio * 100)  # Weighting length diff (you can adjust the *100 factor)
+            # Iterate through each cluster in clustered_sequences
+            for cluster_key, cluster in clustered_sequences.items():
+
+                remaining_sequences_tmp = sequences.copy()  # Track unprocessed sequences
+                remaining_sequences = [entry for entry in remaining_sequences_tmp if entry[0] in
+                                       {seq_entry['header'] for seq_entry in cluster}]
+                sequences_to_remove = []
+
+                while remaining_sequences:
+                    # Track subgroups for this cluster pass
+                    subgroup_sequences = []
+                    genome_seen = set()
+
+                    # Recalculate representative sequence dynamically for this cluster
+                    rep = calculate_new_rep_seq(
+                        [entry for entry in cluster if entry['header'] in (h for h, _ in remaining_sequences)]
+                    )
+
+                    # Find the sequence corresponding to rep['header'] from the list of sequences
+                    rep_seq = next((seq for header, seq in sequences if header == rep['header']), None)
+
+                    # Save previously checked seqs, so we don't have to compare them again.
+                    checked = collections.defaultdict(float)
+
+                    # Process each genome to select the best matching sequence
+                    for genome in genome_to_gene_count:
+                        best_sequence = None
+                        best_score = None  # Initialise with a very low score, so that even negative scores can be selected
+
+                        # Iterate over each sequence in the remaining sequences for this genome
+                        for header, seq in remaining_sequences:
+                            genome_id = header.split('|')[1]
+
+                            if genome_id == genome:  # Ensure this sequence belongs to the current genome
+                                if rep_seq == seq:
+                                    levenshtein_distance = 0
+                                else:
+                                    if seq in checked:
+                                        levenshtein_distance = checked[seq]
+                                    else:
+                                        levenshtein_distance = levenshtein_distance_calc(rep_seq,seq)
+                                        checked[seq] = levenshtein_distance
+                                # Lower Levenshtein distance means more 'similar' sequences
+                                score = levenshtein_distance
 
                                 # Check if this sequence has a higher score than the current best
-                                if score > best_score:
+                                if best_sequence == None:
+                                    best_score = score
+                                    best_sequence = (header, seq)  # Store the best matching sequence for this genome
+                                elif score < best_score:
                                     best_score = score
                                     best_sequence = (header, seq)  # Store the best matching sequence for this genome
 
-                    # Once the best sequence is identified, add it to the subgroup
-                    if best_sequence is not None:
-                        sequences_found = True  # At least one sequence was added
-                        new_header = f">{group_file_name}_subgroup_{subgroup_id}|{best_sequence[0].split('|')[1]}|{best_sequence[0].split('|')[2]}"
-                        subgroup_sequences.append((new_header, best_sequence[1]))
-                        sequences_to_remove.append(best_sequence)
-                        genome_seen.add(genome)
+                        # Add the best sequence for this genome to the subgroup
+                        if best_sequence is not None:
+                            new_header = f">{group_file_name}_subgroup_{subgroup_id}|{best_sequence[0].split('|')[1]}|{best_sequence[0].split('|')[2]}"
+                            subgroup_sequences.append((new_header, best_sequence[1]))
+                            sequences_to_remove.append(best_sequence)
+                            genome_seen.add(genome)
+
+                    # Write each subgroup into a separate FASTA file
+                    if subgroup_sequences:
+                        subgroup_file = f"{options.output_dir}/{group_file_name}_subgroup_{subgroup_id}.fasta"
+                        write_fasta(subgroup_sequences, subgroup_file)
 
-                    # If no sequences were found for this pass, exit the loop
-                    # if not sequences_found:
-                    #     break
+                        # Remove processed sequences from the remaining list
+                        remaining_sequences = [item for item in remaining_sequences if
+                                               item[0] not in {h for h, _ in sequences_to_remove}]
 
-                # Write each subgroup into a separate FASTA file
-                if subgroup_sequences:
-                    subgroup_file = f"{options.output_dir}/{group_file_name}_subgroup_{subgroup_id}.fasta"
-                    write_fasta(subgroup_sequences, subgroup_file)
+                        # Increment subgroup ID for the next subgroup
+                        subgroup_id += 1
+                        paralog_groups[group_name] += 1  # Count this group as a paralog group
 
-                    # Remove processed sequences from the remaining list
-                    remaining_sequences = [item for item in remaining_sequences if
-                                           item[0] not in {h for h, _ in sequences_to_remove}]
 
-                    # Increment subgroup ID globally for the next subgroup
-                    subgroup_id += 1
-                    paralog_groups[group_name] += 1  # Count this group as a paralog group
 
 
         else:
@@ -255,7 +281,7 @@ def separate_groups(input_fasta, options, clustering_mode):
 
                 # Determine the next subgroup for this genome
                 subgroup_id = genome_count[genome] % num_subgroups
-                new_header = f"{options.output_dir}/{group_file_name}_subgroup_{subgroup_id}|{genome}|{header.split('|')[2]}"
+                new_header = f"{group_file_name}_subgroup_{subgroup_id}|{genome}|{header.split('|')[2]}"
                 subgroup_sequences[subgroup_id].append((new_header, seq))
 
                 # Increment the count for this genome
@@ -266,6 +292,12 @@ def separate_groups(input_fasta, options, clustering_mode):
                 subgroup_file = f"{options.output_dir}/{group_file_name}_subgroup_{subgroup_id}.fasta"
                 write_fasta(seqs, subgroup_file)
 
+                # Increment subgroup ID globally for the next subgroup
+                subgroup_id += 1
+                paralog_groups[group_name] += 1  # Count this group as a paralog group
+
+
+
         # Clean up temporary fasta file if the option is set
         if options.delete_temp_files:
             if temp_fasta and os.path.exists(temp_fasta):
@@ -282,54 +314,69 @@ def separate_groups(input_fasta, options, clustering_mode):
 
 
 def main():
-    parser = argparse.ArgumentParser(description='Group-Splitter: ' + PyamilySeq_Version + ': A tool to split "paralogous" groups identified by PyamilySeq.')
+    parser = argparse.ArgumentParser(description='PyamilySeq ' + PyamilySeq_Version + ': Group-Splitter - A tool to split multi-copy gene groups identified by PyamilySeq.')
     ### Required Arguments
-    required = parser.add_argument_group('Required Arguments')
+    required = parser.add_argument_group('Required Parameters')
     required.add_argument('-input_fasta', action='store', dest='input_fasta',
                           help='Input FASTA file containing gene groups.',
                           required=True)
+    required.add_argument('-sequence_type', action='store', dest='sequence_type', default='DNA',choices=['AA', 'DNA'],
+                          help='Default - DNA: Are groups "DNA" or "AA" sequences?',
+                          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('-output_dir', action='store', dest='output_dir',
                           help='Output directory.',
                           required=True)
 
-    optional = parser.add_argument_group('Optional Arguments')
-
-    optional.add_argument('-pident', action='store', dest='pident', type=float, default=0.9,
-                          help='Sequence identity threshold (default: 0.9)')
-    optional.add_argument('-len_diff', action='store', dest='len_diff', type=float, default=0.05,
-                          help='Length difference threshold (default: 0.05)')
-    optional.add_argument('-clustering_threads', action='store', dest='clustering_threads', type=int, default=4,
+    regrouping_params = parser.add_argument_group('Regrouping Parameters')
+    regrouping_params.add_argument('-groups', action="store", dest='groups', default=None,
+                          help='Default - auto: Detect groups to be split (see -group_threshold). '
+                               'Provide "-groups 1,2,3,4" with group IDs to split specific groups.',
+                          required=False)
+    regrouping_params.add_argument('-group_threshold', action='store', dest='group_threshold', type=float, default=80,
+                          help='Minimum percentage of genomes with multi-copy (default: 80.0) - Does not work with "-groups"')
+
+    cdhit_params = parser.add_argument_group('CD-HIT Reclustering Parameters')
+    cdhit_params.add_argument('-c', action='store', dest='pident', type=float, default=0.8,
+                          help='Sequence identity threshold (default: 0.8) - Probably should be higher than what was used in initial clustering.')
+    cdhit_params.add_argument('-s', action='store', dest='len_diff', type=float, default=0.20,
+                          help="Length difference cutoff (default: 0.20) - Often the most impactful parameter to split 'multi-copy' gene groups.")
+    cdhit_params.add_argument('-T', action='store', dest='clustering_threads', type=int, default=4,
                           help='Number of threads for clustering (default: 4)')
-    optional.add_argument('-clustering_memory', action='store', dest='clustering_memory', type=int, default=2000,
+    cdhit_params.add_argument('-M', action='store', dest='clustering_memory', type=int, default=2000,
                           help='Memory limit in MB for clustering (default: 2000)')
-    optional.add_argument('-percent_threshold', action='store', dest='percent_threshold', type=float, default=80,
-                          help='Minimum percentage of genomes with paralogs (default: 80.0)')
-    optional.add_argument('-verbose', action='store_true', dest='verbose', help='Print verbose output.')
-    optional.add_argument('-delete_temp_files', action='store_true', dest='delete_temp_files',
-                          help='Delete all temporary files after processing.')
-
-    misc = parser.add_argument_group('Misc Arguments')
-    misc.add_argument('-v', action='store_true', dest='version',
-                      help='Print out version number and exit',
+
+
+    misc = parser.add_argument_group("Misc Parameters")
+    misc.add_argument('-no_delete_temp_files', action='store_false', dest='delete_temp_files',
+                      help='Default: Delete all temporary files after processing.',
                       required=False)
+    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-Splitter version {PyamilySeq_Version} - Exiting",
+                      help="Print out version number and exit")
+
 
     options = parser.parse_args()
+    print("Running PyamilySeq: Group-Splitter " + PyamilySeq_Version)
 
-    # Check for version flag
-    if options.version:
-        print(f"Group-Splitter version {PyamilySeq_Version}")
-        exit(0)
 
-    options = parser.parse_args()
 
     if not os.path.exists(options.output_dir):
         os.makedirs(options.output_dir)
 
-    clustering_mode = 'cd-hit-est'
-    separate_groups(options.input_fasta, options, clustering_mode)
+    if options.sequence_type == 'DNA':
+        clustering_mode = 'cd-hit-est'
+    else:
+        clustering_mode = 'cd-hit'
 
-    print("Done")
+    separate_groups(options, clustering_mode)
 
 
 if __name__ == "__main__":
+
     main()

PyamilySeq/PyamilySeq.py

@@ -27,9 +27,10 @@ def run_cd_hit(options, input_file, clustering_output, clustering_mode):
         '-o', clustering_output,
         '-c', str(options.pident),
         '-s', str(options.len_diff),
-        '-T', str(options.clustering_threads),
+        '-T', str(options.threads),
         '-M', str(options.clustering_memory),
         '-d', "0",
+        '-g', "1",
         '-sc', "1",
         '-sf', "1"
     ]
@@ -42,7 +43,7 @@ def run_cd_hit(options, input_file, clustering_output, clustering_mode):
 def main():
     parser = argparse.ArgumentParser(description='PyamilySeq ' + PyamilySeq_Version + ': A tool that groups genes into unique clusters.')
     ### Required Arguments
-    required = parser.add_argument_group('Required Arguments')
+    required = parser.add_argument_group('Required Parameters')
     required.add_argument('-run_mode', action='store', dest='run_mode', choices=['Full','Partial'],
                           help='Run Mode: Should PyamilySeq be run in "Full" or "Partial" mode?',
                           required=True)
@@ -56,7 +57,7 @@ def main():
                           help="Directory for all output files.",
                           required=True)
     ### Full-Mode Arguments
-    full_mode_args = parser.add_argument_group('Full-Mode Arguments - Required when "-run_mode Full" is used')
+    full_mode_args = parser.add_argument_group('Full-Mode Parameters - Required when "-run_mode Full" is used')
     full_mode_args.add_argument("-input_type", action="store", dest="input_type", choices=['separate', 'combined'],
                           help="Type of input files: 'separate' for separate FASTA and GFF files,"
                              " 'combined' for GFF files with embedded FASTA sequences.",
@@ -84,18 +85,18 @@ def main():
     clustering_args.add_argument("-mem", action="store", dest="clustering_memory", type=int, default=4000,
                           help="Default 4000: Memory to be allocated for clustering (in MBs).",
                           required=False)
-    clustering_args.add_argument("-t", action="store", dest="clustering_threads", type=int, default=4,
-                          help="Default 4: Threads to be allocated for clustering.",
+    clustering_args.add_argument("-t", action="store", dest="threads", type=int, default=8,
+                          help="Default 8: Threads to be allocated for clustering and/or alignment.",
                           required=False)
 
     ###Partial-Mode Arguments
-    partial_mode_args = parser.add_argument_group('Partial-Mode Arguments - Required when "-run_mode Partial" is used')
-    partial_mode_args.add_argument('-cluster_file', action='store', dest='cluster_file',
-                        help='Clustering output file containing CD-HIT, TSV or CSV Edge List',
+    partial_mode_args = parser.add_argument_group("Partial-Mode Parameters - Required when '-run_mode Partial' is used")
+    partial_mode_args.add_argument("-cluster_file", action="store", dest="cluster_file",
+                        help="Clustering output file containing CD-HIT, TSV or CSV Edge List",
                         required=False)
 
     ###Grouping Arguments
-    grouping_args = parser.add_argument_group('Grouping Arguments - Use to fine-tune grouping of genes after clustering')
+    grouping_args = parser.add_argument_group('Grouping Parameters - Use to fine-tune grouping of genes after clustering')
     grouping_args.add_argument('-reclustered', action='store', dest='reclustered',
                         help='Currently only works on Partial Mode: Clustering output file from secondary round of clustering.',
                         required=False)
@@ -129,18 +130,20 @@ def main():
                           required=False)
 
     ### Misc Arguments
-    misc = parser.add_argument_group('Misc')
-    misc.add_argument('-verbose', action='store_true', dest='verbose', default=None,                        help='Default - False: Print out runtime messages',
-                        required = False)
-    misc.add_argument('-v', action='store_true', dest='version',
-                        help='Default - False: Print out version number and exit',
-                        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 version {PyamilySeq_Version} - Exiting",
+                      help="Print out version number and exit")
+
 
     options = parser.parse_args()
+    print("Running PyamilySeq: " + PyamilySeq_Version)
 
     ### Checking all required parameters are provided by user #!!# Doesn't seem to work
     if options.run_mode == 'Full':
-
         if options.reclustered != None:
             sys.exit("Currently reclustering only works on Partial Mode.")
         required_full_mode = [options.input_type, options.input_dir, options.name_split, options.clustering_format,
@@ -254,6 +257,7 @@ def main():
                 self.output_dir = options.output_dir
                 self.gene_presence_absence_out = options.gene_presence_absence_out
                 self.write_groups = options.write_groups
+                self.threads = options.threads
                 self.align_core = options.align_core
                 self.fasta = combined_out_file
                 self.verbose = options.verbose
@@ -272,6 +276,7 @@ def main():
                 self.output_dir = options.output_dir
                 self.gene_presence_absence_out = options.gene_presence_absence_out
                 self.write_groups = options.write_groups
+                self.threads = options.threads
                 self.align_core = options.align_core
                 self.fasta = options.original_fasta
                 self.verbose = options.verbose
@@ -288,5 +293,4 @@ def main():
           "Please report any issues to: https://github.com/NickJD/PyamilySeq/issues\n#####")
 
 if __name__ == "__main__":
-    print("Running PyamilySeq "+PyamilySeq_Version)
     main()

PyamilySeq/Seq_Combiner.py

@@ -11,7 +11,7 @@ except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
 
 
 def main():
-    parser = argparse.ArgumentParser(description='Seq-Combiner ' + PyamilySeq_Version + ': A tool to extract sequences from GFF/FASTA files.')
+    parser = argparse.ArgumentParser(description='PyamilySeq ' + PyamilySeq_Version + ': Seq-Combiner - A tool to extract sequences from GFF/FASTA files and prepare them for PyamilySeq.')
     ### Required Arguments
     required = parser.add_argument_group('Required Arguments')
     required.add_argument('-input_dir', action='store', dest='input_dir',
@@ -31,6 +31,7 @@ def main():
     required.add_argument("-output_name", action="store", dest="output_file",
                           help="Output file name.",
                           required=True)
+
     optional = parser.add_argument_group('Optional Arguments')
     optional.add_argument('-gene_ident', action='store', dest='gene_ident', default='CDS',
                           help='Default - "CDS": Identifier used for extraction of sequences such as "misc_RNA,gene,mRNA,CDS,rRNA,tRNA,tmRNA,CRISPR,ncRNA,regulatory_region,oriC,pseudo"'
@@ -40,9 +41,9 @@ def main():
                           help='Default - False: Translate extracted sequences to their AA counterpart?',
                           required=False)
     misc = parser.add_argument_group('Misc Arguments')
-    misc.add_argument('-v', action='store_true', dest='version',
-                         help='Print out version number and exit',
-                         required=False)
+    misc.add_argument("-v", "--version", action="version",
+                      version=f"PyamilySeq: Seq-Combiner version {PyamilySeq_Version} - Exiting",
+                      help="Print out version number and exit")
 
     options = parser.parse_args()
 
@@ -50,6 +51,9 @@ def main():
         sys.exit(PyamilySeq_Version)
 
     output_path = os.path.abspath(options.output_dir)
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+
     combined_out_file = os.path.join(output_path, options.output_file)
 
     if options.input_type == 'separate':

PyamilySeq/utils.py

@@ -6,7 +6,42 @@ import collections
 from tempfile import NamedTemporaryFile
 import sys
 from line_profiler_pycharm import profile
-
+import re
+
+####
+# Placeholder for the distance function
+levenshtein_distance_cal = None
+# Check for Levenshtein library once
+try:
+    import Levenshtein as LV
+    # Assign the optimized function
+    def levenshtein_distance_calc(seq1, seq2):
+        return LV.distance(seq1, seq2)
+except (ModuleNotFoundError, ImportError):
+    print("Levenshtein package not installed - Will fallback to slower Python implementation.")
+    # Fallback implementation
+    def levenshtein_distance_calc(seq1, seq2):
+        # Slower Python implementation of Levenshtein distance
+        len1, len2 = len(seq1), len(seq2)
+        dp = [[0] * (len2 + 1) for _ in range(len1 + 1)]
+
+        for i in range(len1 + 1):
+            dp[i][0] = i
+        for j in range(len2 + 1):
+            dp[0][j] = j
+
+        for i in range(1, len1 + 1):
+            for j in range(1, len2 + 1):
+                if seq1[i - 1] == seq2[j - 1]:
+                    cost = 0
+                else:
+                    cost = 1
+                dp[i][j] = min(dp[i - 1][j] + 1,  # Deletion
+                               dp[i][j - 1] + 1,  # Insertion
+                               dp[i - 1][j - 1] + cost)  # Substitution
+
+        return dp[len1][len2]
+#####
 
 ################### We are currently fixed using Table 11
 gencode = {
@@ -31,63 +66,6 @@ def translate_frame(sequence):
     translate = ''.join([gencode.get(sequence[3 * i:3 * i + 3], 'X') for i in range(len(sequence) // 3)])
     return translate
 
-@profile
-def calculate_similarity(seq1, seq2):
-    len1, len2 = len(seq1), len(seq2)
-
-    # If lengths are the same, directly compare without alignment
-    if len1 == len2:
-        matches = sum(c1 == c2 for c1, c2 in zip(seq1, seq2))
-        return (matches / len1) * 100  # Return similarity based on the length
-
-    # For different lengths, proceed with global alignment
-    # Initialize the scoring matrix
-    score_matrix = [[0] * (len2 + 1) for _ in range(len1 + 1)]
-
-    # Fill the first row and first column with gap penalties
-    for i in range(len1 + 1):
-        score_matrix[i][0] = -i  # Gap penalty for seq1
-    for j in range(len2 + 1):
-        score_matrix[0][j] = -j  # Gap penalty for seq2
-
-    # Fill the score matrix
-    for i in range(1, len1 + 1):
-        for j in range(1, len2 + 1):
-            match = score_matrix[i - 1][j - 1] + (1 if seq1[i - 1] == seq2[j - 1] else -1)
-            delete = score_matrix[i - 1][j] - 1  # Gap in seq2
-            insert = score_matrix[i][j - 1] - 1  # Gap in seq1
-            score_matrix[i][j] = max(match, delete, insert)
-
-    # Traceback to find the alignment (if needed for detailed output)
-    aligned_seq1, aligned_seq2 = "", ""
-    i, j = len1, len2
-
-    while i > 0 or j > 0:
-        current_score = score_matrix[i][j]
-        if i > 0 and j > 0 and current_score == score_matrix[i - 1][j - 1] + (1 if seq1[i - 1] == seq2[j - 1] else -1):
-            aligned_seq1 += seq1[i - 1]
-            aligned_seq2 += seq2[j - 1]
-            i -= 1
-            j -= 1
-        elif i > 0 and current_score == score_matrix[i - 1][j] - 1:
-            aligned_seq1 += seq1[i - 1]
-            aligned_seq2 += "-"
-            i -= 1
-        else:
-            aligned_seq1 += "-"
-            aligned_seq2 += seq2[j - 1]
-            j -= 1
-
-    # Reverse the aligned sequences if needed
-    aligned_seq1 = aligned_seq1[::-1]
-    aligned_seq2 = aligned_seq2[::-1]
-
-    # Calculate matches from aligned sequences
-    matches = sum(c1 == c2 for c1, c2 in zip(aligned_seq1, aligned_seq2))
-
-    # Calculate the similarity percentage based on the maximum length
-    max_length = max(len(seq1), len(seq2))
-    return (matches / max_length) * 100
 
 
 
@@ -110,12 +88,24 @@ def reverse_complement(seq):
     complement = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G', 'N': 'N'}
     return ''.join(complement[base] for base in reversed(seq))
 
+
 def fix_path(path):
     fixed_path = os.path.normpath(path)
     fixed_path = os.path.realpath(fixed_path)
     return fixed_path
 
 
+def extract_identity(clustered_info):
+    # Use regex to capture percentage, including optional '-' or '+' before it
+    match = re.search(r'at [+-/]*(\d+\.\d+)%', clustered_info)
+
+    if match:
+        percent_identity = float(match.group(1))  # Extract the percentage value
+        return percent_identity
+    else:
+        raise ValueError("Percent identity not found in the string.")
+
+
 def wrap_sequence(sequence, width=60):
     wrapped_sequence = []
     for i in range(0, len(sequence), width):
@@ -172,14 +162,15 @@ def run_mafft_on_sequences(options, sequences, output_file):
         with open(output_file, 'w') as output_f:
             if options.verbose == True:
                 subprocess.run(
-                    ['mafft', '--auto', temp_input_file_path],
+                    ['mafft', '--auto', '--thread', str(options.threads), temp_input_file_path],
                     stdout=output_f,
                     stderr=sys.stderr,
                     check=True
                 )
+
             else:
                 subprocess.run(
-                    ['mafft', '--auto', temp_input_file_path],
+                    ['mafft', '--auto', '--thread', str(options.threads), temp_input_file_path],
                     stdout=output_f,
                     stderr=subprocess.DEVNULL,  # Suppress stderr
                     check=True
@@ -385,7 +376,7 @@ def process_gene_families(options, directory, output_file):
 
     # Iterate over each gene family file
     for gene_file in os.listdir(directory):
-        if gene_file.endswith('.fasta'):
+        if gene_file.endswith('.fasta') and not gene_file.endswith('combined_group_sequences.fasta'):
             gene_path = os.path.join(directory, gene_file)
 
             # Read sequences from the gene family file
@@ -395,7 +386,7 @@ def process_gene_families(options, directory, output_file):
             longest_sequences = select_longest_gene(sequences)
 
             # Run mafft on the longest sequences
-            aligned_file = f"{gene_file}_aligned.fasta"
+            aligned_file = f"{directory}/{gene_file}_aligned.fasta.tmp"
             run_mafft_on_sequences(options, {seq_id: seq for seq_id, seq in longest_sequences.values()}, aligned_file)
 
             # Read aligned sequences and concatenate them

{PyamilySeq-0.8.0.dist-info → PyamilySeq-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyamilySeq
-Version: 0.8.0
+Version: 0.9.0
 Summary: PyamilySeq - A a tool to look for sequence-based gene groups identified by clustering methods such as CD-HIT, DIAMOND, BLAST or MMseqs2.
 Home-page: https://github.com/NickJD/PyamilySeq
 Author: Nicholas Dimonaco
@@ -12,6 +12,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: levenshtein
 
 # PyamilySeq - !BETA!
 **PyamilySeq** is a Python tool for clustering gene sequences into groups based on sequence similarity identified by tools such as CD-HIT, BLAST, DIAMOND or MMseqs2.
@@ -34,19 +35,18 @@ PyamilySeq probably requires Python 3.6 or higher. Install using pip:
 ```bash
 pip install PyamilySeq
 ```
-
+PyamilySeq is regularly updated with bugfixes and new features so to update to the newest version add '-U' to end of the pip install command.
 ## Example usage: Below are two examples of running PyamilySeq in its two main modes.
 ### 'Full Mode': Will conduct clustering of sequences with CD-HIT as part of PyamilySeq run
 ```
 PyamilySeq -run_mode Full -group_mode Species -clustering_format CD-HIT  -output_dir .../test_data/testing/Full 
--input_type combined -input_dir .../test_data/genomes -name_split _combined.gff3 -pid 0.95 -len_diff 0.80 
--gpa -a -w 99
+-input_type combined -input_dir .../test_data/genomes -name_split _combined.gff3 -pid 0.95 -len_diff 0.80 -a -w 99
 ```
 ### 'Partial Mode': Will take the output of a sequence clustering.
 ```
-PyamilySeq -run_mode Partial -group_mode Species -clustering_format TSV -output_dir .../test_data/Species/testing/Partial 
--cluster_file .../test_data/Species/MMseqs2/combined_Ensmbl_pep_cluster.tsv 
--original_fasta .../test_data/species/combined_Ensmbl_cds.fasta -gpa -a -w 99 -verbose 
+PyamilySeq -run_mode Partial -group_mode Species -clustering_format TSV -output_dir .../test_data/species/testing/Partial 
+-cluster_file .../test_data/species/MMseqs2/combined_Ensmbl_pep_cluster.tsv 
+-original_fasta .../test_data/species/combined_Ensmbl_cds.fasta -a -w 99 -verbose 
 
 ```
 #### Note: '-clustering_format TSV/CSV' requires input to be two in two columns as below (Same format as MMseqs2 tsv) - Genome name and sequence name are separated by '|'.
@@ -58,7 +58,7 @@ Escherichia_coli_110957|ENSB:TIZS9kbTvShDvyX	Escherichia_coli_110957|ENSB:TIZS9k
 ```
 ### Example output:
 ```
-Running PyamilySeq v0.8.0
+Running PyamilySeq v0.9.0
 Calculating Groups
 Gene Groups:
 First_core_99: 2682
@@ -80,7 +80,7 @@ PyamilySeq -run_mode Partial -group_mode Genus -clustering_format CD-HIT -output
  -cluster_file .../test_data/genus/CD-HIT/combined_cds_cd-hit_80_60.clstr -gpa 
 ```
 ```commandline
-Running PyamilySeq v0.8.0
+Running PyamilySeq v0.9.0
 Calculating Groups
 Genus Groups:
 First_genera_1:	28549
@@ -137,14 +137,14 @@ Please report any issues to: https://github.com/NickJD/PyamilySeq/issues
 ## PyamilySeq - Menu: 
 ### PyamilySeq is separated into two main 'run modes', Full and Partial. They each have their own set of required and optional arguments. 
 ```
-Running PyamilySeq v0.8.0
+Running PyamilySeq v0.9.0
 usage: PyamilySeq.py [-h] -run_mode {Full,Partial} -group_mode {Species,Genus} -clustering_format {CD-HIT,TSV,CSV} -output_dir OUTPUT_DIR
                      [-input_type {separate,combined}] [-input_dir INPUT_DIR] [-name_split NAME_SPLIT] [-sequence_type {AA,DNA}] [-gene_ident GENE_IDENT]
                      [-pid PIDENT] [-len_diff LEN_DIFF] [-mem CLUSTERING_MEMORY] [-t CLUSTERING_THREADS] [-cluster_file CLUSTER_FILE]
                      [-reclustered RECLUSTERED] [-seq_tag SEQUENCE_TAG] [-core_groups CORE_GROUPS] [-genus_groups GENUS_GROUPS] [-w WRITE_GROUPS] [-a]
                      [-original_fasta ORIGINAL_FASTA] [-gpa] [-verbose] [-v]
 
-PyamilySeq v0.8.0: A tool that groups genes into unique clusters.
+PyamilySeq v0.9.0: A tool that groups genes into unique clusters.
 
 options:
   -h, --help            show this help message and exit
@@ -176,8 +176,9 @@ Full-Mode Arguments - Required when "-run_mode Full" is used:
 Clustering Runtime Arguments - Optional when "-run_mode Full" is used:
   -mem CLUSTERING_MEMORY
                         Default 4000: Memory to be allocated for clustering (in MBs).
-  -t CLUSTERING_THREADS
-                        Default 4: Threads to be allocated for clustering.
+  -t THREADS            Default 8: Threads to be allocated for clustering
+                        and/or alignment.
+
 
 Partial-Mode Arguments - Required when "-run_mode Partial" is used:
   -cluster_file CLUSTER_FILE
@@ -197,15 +198,16 @@ Output Parameters:
   -w WRITE_GROUPS       Default - No output: Output sequences of identified groups (provide levels at which to output - Species "-w 99,95" Genus "-w 2,3" -
                         Must provide FASTA file with -original_fasta if in Partial run mode.
   -a                    Default - No output: SLOW! (Only works for Species mode) Output aligned and concatinated sequences of identified groups -provide
-                        group levels at which to output "-w 99,95" - Must provide FASTA file with -original_fasta in Partial run mode.
+                        group levels at which to output "-w 99,95" - Must provide FASTA file with -original_fasta in Partialrun mode.
   -original_fasta ORIGINAL_FASTA
-                        FASTA file to use in conjunction with "-w" or "-a" when running in Partial Mode.
-  -gpa                  Default - False: If selected, a Roary/Panaroo formatted gene_presence_absence.csv will be created - Required for Coinfinder and
-                        other downstream tools
+                        FASTA file to use in conjunction with "-w" or "-con" when running in Partial Mode.
+  -no_gpa               Do not create a Roary/Panaroo formatted gene_presence_absence.csv (created by default) - Required for Coinfinder and other
+                        downstream tools
+
+Misc Parameters:
+  -verbose              Print verbose output.
+  -v, --version         Print out version number and exit
 
-Misc:
-  -verbose              Default - False: Print out runtime messages
-  -v                    Default - False: Print out version number and exit
 ```
 
 
@@ -215,13 +217,14 @@ Misc:
 ## Seq-Combiner: This tool is provided to enable the pre-processing of multiple GFF/FASTA files together ready to be clustered by the user.
 ### Example:
 ```bash
-Seq-Combiner -input_dir .../test_data/genomes -name_split _combined.gff3 -output_dir.../test_data -output_name combine_fasta_seqs.fa -input_type combined
+Seq-Combiner -input_dir .../test_data/genomes -name_split .gff3 -output_dir .../test_data/genomes -output_name combine_fasta_seqs.fa -input_type combined
 ```
 ### Seq-Combiner Menu:
 ```
-usage: Seq_Combiner.py [-h] -input_dir INPUT_DIR -input_type {separate,combined,fasta} -name_split NAME_SPLIT -output_dir OUTPUT_DIR -output_name OUTPUT_FILE [-gene_ident GENE_IDENT] [-translate] [-v]
+usage: Seq_Combiner.py [-h] -input_dir INPUT_DIR -input_type {separate,combined,fasta} -name_split NAME_SPLIT -output_dir OUTPUT_DIR -output_name
+                       OUTPUT_FILE [-gene_ident GENE_IDENT] [-translate] [-v]
 
-Seq-Combiner v0.8.0: A tool to extract sequences from GFF/FASTA files.
+PyamilySeq v0.9.0: Seq-Combiner - A tool to extract sequences from GFF/FASTA files and prepare them for PyamilySeq.
 
 options:
   -h, --help            show this help message and exit
@@ -229,7 +232,8 @@ options:
 Required Arguments:
   -input_dir INPUT_DIR  Directory location where the files are located.
   -input_type {separate,combined,fasta}
-                        Type of input files: "separate" for separate FASTA and GFF files, "combined" for GFF files with embedded FASTA sequences and "fasta" for combining multiple FASTA files together.
+                        Type of input files: "separate" for separate FASTA and GFF files, "combined" for GFF files with embedded FASTA sequences and "fasta"
+                        for combining multiple FASTA files together.
   -name_split NAME_SPLIT
                         substring used to split the filename and extract the genome name ('_combined.gff3' or '.gff').
   -output_dir OUTPUT_DIR
@@ -239,46 +243,103 @@ Required Arguments:
 
 Optional Arguments:
   -gene_ident GENE_IDENT
-                        Default - "CDS": Identifier used for extraction of sequences such as "misc_RNA,gene,mRNA,CDS,rRNA,tRNA,tmRNA,CRISPR,ncRNA,regulatory_region,oriC,pseudo" - Not compatible with "fasta" input mode.
+                        Default - "CDS": Identifier used for extraction of sequences such as
+                        "misc_RNA,gene,mRNA,CDS,rRNA,tRNA,tmRNA,CRISPR,ncRNA,regulatory_region,oriC,pseudo" - Not compatible with "fasta" input mode.
   -translate            Default - False: Translate extracted sequences to their AA counterpart?
 
 Misc Arguments:
-  -v                    Print out version number and exit
-
+  -v, --version         Print out version number and exit
 
 ```
 
-### Group-Splitter menu: 
-
+## Group-Splitter: This tool can split multi-copy gene groups using CD-HIT after initial PyamilySeq analysis.
+### Example:
+```bash
+Group-Splitter -genome_num 74 -input_fasta .../test/species/ -output_dir .../test/species/ -sequence_type AA
 ```
-usage: Group_Splitter.py [-h] -input_fasta INPUT_FASTA -output_dir OUTPUT_DIR [-pident PIDENT] [-len_diff LEN_DIFF] [-clustering_threads CLUSTERING_THREADS]
-                         [-clustering_memory CLUSTERING_MEMORY] [-percent_threshold PERCENT_THRESHOLD] [-verbose] [-delete_temp_files] [-v]
+### Group-Splitter Menu:
+```
+usage: Group_Splitter.py [-h] -input_fasta INPUT_FASTA -sequence_type {AA,DNA}
+                         -genome_num GENOME_NUM -output_dir OUTPUT_DIR
+                         [-groups GROUPS] [-group_threshold GROUP_THRESHOLD]
+                         [-c PIDENT] [-s LEN_DIFF] [-T CLUSTERING_THREADS]
+                         [-M CLUSTERING_MEMORY] [-no_delete_temp_files]
+                         [-verbose] [-v]
 
-Group-Splitter: v0.8.0: A tool to split "paralogous" groups identified by PyamilySeq.
+PyamilySeq v0.9.0: Group-Splitter - A tool to split multi-copy gene groups
+identified by PyamilySeq.
 
 options:
   -h, --help            show this help message and exit
 
-Required Arguments:
+Required Parameters:
   -input_fasta INPUT_FASTA
                         Input FASTA file containing gene groups.
+  -sequence_type {AA,DNA}
+                        Default - DNA: Are groups "DNA" or "AA" sequences?
+  -genome_num GENOME_NUM
+                        The total number of genomes must be provide
   -output_dir OUTPUT_DIR
                         Output directory.
 
-Optional Arguments:
-  -pident PIDENT        Sequence identity threshold (default: 0.9)
-  -len_diff LEN_DIFF    Length difference threshold (default: 0.05)
-  -clustering_threads CLUSTERING_THREADS
+Regrouping Parameters:
+  -groups GROUPS        Default - auto: Detect groups to be split (see
+                        -group_threshold). Provide "-groups 1,2,3,4" with
+                        group IDs to split specific groups.
+  -group_threshold GROUP_THRESHOLD
+                        Minimum percentage of genomes with multi-copy
+                        (default: 80.0) - Does not work with "-groups"
+
+CD-HIT Reclustering Parameters:
+  -c PIDENT             Sequence identity threshold (default: 0.8) - Probably
+                        should be higher than what was used in initial
+                        clustering.
+  -s LEN_DIFF           Length difference cutoff (default: 0.20) - Often the
+                        most impactful parameter to split 'multi-copy' gene
+                        groups.
+  -T CLUSTERING_THREADS
                         Number of threads for clustering (default: 4)
-  -clustering_memory CLUSTERING_MEMORY
-                        Memory limit in MB for clustering (default: 2000)
-  -percent_threshold PERCENT_THRESHOLD
-                        Minimum percentage of genomes with paralogs (default: 80.0)
+  -M CLUSTERING_MEMORY  Memory limit in MB for clustering (default: 2000)
+
+Misc Parameters:
+  -no_delete_temp_files
+                        Default: Delete all temporary files after processing.
   -verbose              Print verbose output.
-  -delete_temp_files    Delete all temporary files after processing.
+  -v, --version         Print out version number and exit
+
+```
+
+## Cluster-Summary menu: This tool can be used to summarise CD-HIT .clstr files:
+### Example:
+```bash
+Cluster-Summary -genome_num 74 -input_clstr .../test_data/species/E-coli/E-coli_extracted_pep_cd-hit_80.clstr -output_tsv .../test_data/species/E-coli/E-coli_extracted_pep_cd-hit_80_Summary.tsv
+```
+### Cluster-Summary Menu: 
+```
+usage: Cluster_Summary.py [-h] -input_clstr INPUT_CLSTR -output OUTPUT -genome_num GENOME_NUM
+                          [-output_dir OUTPUT_DIR] [-verbose] [-v]
+
+PyamilySeq v0.9.0: Cluster-Summary - A tool to summarise CD-HIT clustering files.
+
+options:
+  -h, --help            show this help message and exit
+
+Required Parameters:
+  -input_clstr INPUT_CLSTR
+                        Input CD-HIT .clstr file
+  -output OUTPUT        Output TSV file to store cluster summaries - Will add '.tsv' if not
+                        provided by user
+  -genome_num GENOME_NUM
+                        The total number of genomes must be provide
+
+Optional Arguments:
+  -output_dir OUTPUT_DIR
+                        Default: Same as input file
+
+Misc Parameters:
+  -verbose              Print verbose output.
+  -v, --version         Print out version number and exit
 
-Misc Arguments:
-  -v                    Print out version number and exit
 ```
 
 ### All example input and output data can be found  in the 'test_data' directory.

PyamilySeq-0.9.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+PyamilySeq/Cluster_Summary.py,sha256=OwAPjODoFIECQUGuPywXORdQn-wHqyRnIIhxSzLTm2E,6982
+PyamilySeq/Constants.py,sha256=ubY4rmpkQIwxfY6vq4rjO34PtlQPWEJyinwFke3BSGE,31
+PyamilySeq/Group_Splitter.py,sha256=QQD5gK1QhMDlqMhLvLWsq-Eh8-k2vC-h4L8bqdkGpXE,17445
+PyamilySeq/PyamilySeq.py,sha256=Frl21S-l4fZdDLFoqeTxB5QqMdsKq5VSQv98Xf_uxMU,15283
+PyamilySeq/PyamilySeq_Genus.py,sha256=hC34cHIFu8YaXXgcPyVwuWENlsxx-7mT-Qr6PAdio4U,12414
+PyamilySeq/PyamilySeq_Species.py,sha256=spgS-h-lrySZBiOiB6jX6pPRaL5j8f5V1Hq3XOjBOko,14404
+PyamilySeq/Seq_Combiner.py,sha256=hMXmA-M3tduONX4pM5qDb2dzBIFLdsIsWLezejxowhQ,3521
+PyamilySeq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PyamilySeq/clusterings.py,sha256=rcWFv0IiWoS4aUNRjDDwNEL86l1wIKa4vK4htAxy8Hg,18787
+PyamilySeq/utils.py,sha256=sjsx5oAIPacvVbfURqPwoq7XfZIk9V_PhGugBVT6jLE,18626
+PyamilySeq-0.9.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+PyamilySeq-0.9.0.dist-info/METADATA,sha256=gsO5symEXI7C8SGzLD2SfyIcCt9yYmbXBIoBCU05BL8,16958
+PyamilySeq-0.9.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+PyamilySeq-0.9.0.dist-info/entry_points.txt,sha256=KuGG_QEvagQHf-Ftohb1oItkx_SknDq66wcOiBqb7PY,200
+PyamilySeq-0.9.0.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
+PyamilySeq-0.9.0.dist-info/RECORD,,

{PyamilySeq-0.8.0.dist-info → PyamilySeq-0.9.0.dist-info}/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
+Cluster-Summary = PyamilySeq.Cluster_Summary:main
 Group-Splitter = PyamilySeq.Group_Splitter:main
 PyamilySeq = PyamilySeq.PyamilySeq:main
 Seq-Combiner = PyamilySeq.Seq_Combiner:main

PyamilySeq-0.8.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-PyamilySeq/Constants.py,sha256=lbVZv4vDHroA83KCDTIGuVb6bubKYZbwLmhYHxedXQc,31
-PyamilySeq/Group_Splitter.py,sha256=raZMV9SN7Qqw5Hci5qpkaahR66JMQf6dX8TvThjh3kU,14986
-PyamilySeq/PyamilySeq.py,sha256=0607A9nqafoQ8IhBxGgGJ-v3DVV6C6-LgzdDIXb2C-c,15179
-PyamilySeq/PyamilySeq_Genus.py,sha256=hC34cHIFu8YaXXgcPyVwuWENlsxx-7mT-Qr6PAdio4U,12414
-PyamilySeq/PyamilySeq_Species.py,sha256=spgS-h-lrySZBiOiB6jX6pPRaL5j8f5V1Hq3XOjBOko,14404
-PyamilySeq/Seq_Combiner.py,sha256=dPDu6LlT3B-ZDn3wKZ3AeWraDgv2Tub_16l9CLc3tQ0,3353
-PyamilySeq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-PyamilySeq/clusterings.py,sha256=rcWFv0IiWoS4aUNRjDDwNEL86l1wIKa4vK4htAxy8Hg,18787
-PyamilySeq/utils.py,sha256=6UtYJW3_0rDhEhvrJi6R3smvKu2n_bjqUkuzr5DcJM4,19061
-PyamilySeq-0.8.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-PyamilySeq-0.8.0.dist-info/METADATA,sha256=ZnpQvAQy5EXGrzS0G9y5qH2Rhmb0LW2HvOT-b5WJLoo,14436
-PyamilySeq-0.8.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-PyamilySeq-0.8.0.dist-info/entry_points.txt,sha256=15BsozBN6vRWvZeQon05dY4YQT7DqP5i2TUqFWRGCvc,150
-PyamilySeq-0.8.0.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
-PyamilySeq-0.8.0.dist-info/RECORD,,