PyamilySeq 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

PyamilySeq/Constants.py

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

PyamilySeq/Group_Splitter.py

@@ -0,0 +1,335 @@
+import subprocess
+import os
+import argparse
+from collections import defaultdict, OrderedDict
+from line_profiler_pycharm import profile
+
+try:
+    from .Constants import *
+    from .utils import *
+except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
+    from Constants import *
+    from utils import *
+
+def run_cd_hit(options, input_file, clustering_output, clustering_mode):
+    cdhit_command = [
+        clustering_mode,
+        '-i', input_file,
+        '-o', clustering_output,
+        '-c', str(options.pident),
+        '-s', str(options.len_diff),
+        '-T', str(options.clustering_threads),
+        '-M', str(options.clustering_memory),
+        '-d', "0",
+        '-sc', "1",
+        '-sf', "1"
+    ]
+    if options.verbose:
+        subprocess.run(cdhit_command)
+    else:
+        subprocess.run(cdhit_command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def calculate_new_rep_seq(cluster_data):
+    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)
+
+    # 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
+
+    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
+
+
+def check_if_all_identical(clustered_sequences):
+    lengths = {entry['length'] for cluster in clustered_sequences.values() for entry in cluster}
+    perc_idents = {entry['percent_identity'] for cluster in clustered_sequences.values() for entry in cluster}
+
+    return len(lengths) == 1 and len(perc_idents) == 1
+
+
+def read_fasta_groups(fasta_file):
+    groups = defaultdict(list)
+    genome_count = defaultdict(int)
+    current_group = None
+    current_sequence = []
+
+    with open(fasta_file, 'r') as f:
+        for line in f:
+            if line.startswith('>'):
+                if current_group is not None:
+                    groups[current_group].append((current_group_header, ''.join(current_sequence)))
+
+                current_group_header = line.strip()
+                current_group = current_group_header.split('|')[0]
+                genome = current_group_header.split('|')[1]
+                current_sequence = []
+                genome_count[genome] += 1
+            else:
+                current_sequence.append(line.strip())
+
+        if current_group is not None:
+            groups[current_group].append((current_group_header, ''.join(current_sequence)))
+
+    return groups, genome_count
+
+
+def write_fasta(sequences, output_file):
+    with open(output_file, 'w') as f:
+        for header, seq in sequences:
+            f.write(f"{header}\n{seq}\n")
+
+
+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:
+                        percent_identity = float(clustered_info.split('at +/')[1].strip().replace('%', ''))
+
+                    if '*' in line:
+                        percent_identity = 100.0
+
+                    clusters[current_cluster_id].append({
+                        'header': clustered_header,
+                        'length': length,
+                        'percent_identity': percent_identity
+                    })
+
+    return clusters
+
+
+def separate_groups(input_fasta, options, clustering_mode):
+    groups, genome_count = read_fasta_groups(input_fasta)
+
+    paralog_groups = defaultdict(int)  # To track number of paralog groups
+
+
+    for group_header, sequences in groups.items():
+        group_name = group_header.split('|')[0]  # Get the group part (e.g., '>Group_n')
+
+        # Count genomes with more than one gene
+        genome_to_gene_count = defaultdict(int)
+        for header, _ in sequences:
+            genome = header.split('|')[1]
+            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
+
+        group_file_name = group_name.replace('>','')
+
+        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)
+
+        # **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)
+
+                                # Check if this sequence has a higher score than the current best
+                                if 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)
+
+                    # If no sequences were found for this pass, exit the loop
+                    # if not sequences_found:
+                    #     break
+
+                # 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)
+
+                    # 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:
+            # Condition 2: If sequences are identical, distribute genes evenly into subgroups
+            num_subgroups = 1000
+            subgroup_sequences = defaultdict(list)  # Store sequences for each subgroup
+            genome_count = defaultdict(int)  # Count how many genes have been assigned to each genome
+
+            # Iterate over all sequences regardless of whether the genome has been seen
+            for header, seq in sequences:
+                genome = header.split('|')[1]
+
+                # 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]}"
+                subgroup_sequences[subgroup_id].append((new_header, seq))
+
+                # Increment the count for this genome
+                genome_count[genome] += 1
+
+            # Write out each subgroup to a separate FASTA file
+            for subgroup_id, seqs in subgroup_sequences.items():
+                subgroup_file = f"{options.output_dir}/{group_file_name}_subgroup_{subgroup_id}.fasta"
+                write_fasta(seqs, subgroup_file)
+
+        # Clean up temporary fasta file if the option is set
+        if options.delete_temp_files:
+            if temp_fasta and os.path.exists(temp_fasta):
+                os.remove(temp_fasta)
+            if os.path.exists(clustering_output + '.clstr'):
+                os.remove(clustering_output + '.clstr')
+            if os.path.exists(clustering_output):
+                os.remove(clustering_output)
+
+    # Print metrics about paralog groups
+    print(f"Identified {len(paralog_groups)} paralog groups:")
+    for group_id, count in paralog_groups.items():
+        print(f"Group ID: {group_id}, Number of new groups: {count}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Group-Splitter: ' + PyamilySeq_Version + ': A tool to split "paralogous" groups identified by PyamilySeq.')
+    ### Required Arguments
+    required = parser.add_argument_group('Required Arguments')
+    required.add_argument('-input_fasta', action='store', dest='input_fasta',
+                          help='Input FASTA file containing gene groups.',
+                          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,
+                          help='Number of threads for clustering (default: 4)')
+    optional.add_argument('-clustering_memory', 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',
+                      required=False)
+
+    options = parser.parse_args()
+
+    # 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)
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

PyamilySeq/PyamilySeq.py

@@ -124,8 +124,8 @@ def main():
     output_args.add_argument('-original_fasta', action='store', dest='original_fasta',
                           help='FASTA file to use in conjunction with "-w" or "-con" when running in Partial Mode.',
                           required=False)
-    output_args.add_argument('-gpa', action='store_true', dest='gene_presence_absence_out', default=None,
-                             help='Default - False: If selected, a Roary/Panaroo formatted gene_presence_absence.csv will be created - Required for Coinfinder and other downstream tools',
+    output_args.add_argument('-no_gpa', action='store_false', dest='gene_presence_absence_out',
+                          help='Do not create a Roary/Panaroo formatted gene_presence_absence.csv (created by default) - Required for Coinfinder and other downstream tools',
                           required=False)
 
     ### Misc Arguments

PyamilySeq/PyamilySeq_Genus.py

@@ -199,7 +199,7 @@ def cluster(options):
             outfile.write("\nTotal Number of First Gene Groups That Had Additional Second Sequences But Not New Genomes: " + str(
                 Number_Of_Second_Extending_But_Same_Genomes))
 
-    if options.gene_presence_absence_out != None:
+    if options.gene_presence_absence_out != False:
         gene_presence_absence_output(options,genus_dict, pangenome_clusters_First_sorted, pangenome_clusters_First_sequences_sorted)
 
     if options.run_mode == 'Full':

PyamilySeq/PyamilySeq_Species.py

@@ -12,6 +12,8 @@ except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
     from utils import *
 
 
+#def output_fasta(options, gene_families):
+
 def gene_presence_absence_output(options, genome_dict, pangenome_clusters_First_sorted, pangenome_clusters_First_sequences_sorted):
     print("Outputting gene_presence_absence file")
     output_dir = os.path.abspath(options.output_dir)
@@ -227,7 +229,7 @@ def cluster(options):
             outfile.write("\nTotal Number of First Gene Groups That Had Additional Second Sequences But Not New Genomes: " + str(
                 Number_Of_Second_Extending_But_Same_Genomes))
         #Report number of first and second clusters and do the ame for genus
-    if options.gene_presence_absence_out != None:
+    if options.gene_presence_absence_out != False:
         gene_presence_absence_output(options,genome_dict, pangenome_clusters_First_sorted, pangenome_clusters_First_sequences_sorted)
 
 
@@ -255,7 +257,6 @@ def cluster(options):
         if options.write_groups != None and options.fasta != None:
             print("Outputting gene group FASTA files")
             sequences = read_fasta(options.fasta)
-            #output_dir = os.path.dirname(os.path.abspath(options.output_dir))
             output_dir = os.path.join(options.output_dir, 'Gene_Families_Output')
             write_groups(options,output_dir, key_order, cores, sequences,
                          pangenome_clusters_First_sequences_sorted, combined_pangenome_clusters_Second_sequences)

PyamilySeq/utils.py

@@ -5,6 +5,7 @@ import glob
 import collections
 from tempfile import NamedTemporaryFile
 import sys
+from line_profiler_pycharm import profile
 
 
 ################### We are currently fixed using Table 11
@@ -30,6 +31,66 @@ 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
+
+
+
 def is_tool_installed(tool_name):
     """Check if a tool is installed and available in PATH."""
     # Check if the tool is in the system PATH
@@ -265,30 +326,57 @@ def read_fasta_files(input_dir, name_split, combined_out, translate):
                     combined_out_file.write(f">{genome_name}|{id}\n{wrapped_sequence}\n")
 
 
-def write_groups(options,output_dir, key_order, cores, sequences, pangenome_clusters_First_sequences_sorted, combined_pangenome_clusters_Second_sequences):
+def write_groups(options, output_dir, key_order, cores, sequences,
+                 pangenome_clusters_First_sequences_sorted, combined_pangenome_clusters_Second_sequences):
+    """
+    Writes individual FASTA files and a combined FASTA file for all sequences.
+
+    Parameters:
+    - options: Command-line options.
+    - output_dir: Directory where output FASTA files will be saved.
+    - key_order: The order in which to process keys.
+    - cores: Dictionary of core genes.
+    - sequences: Dictionary mapping headers to sequences.
+    - pangenome_clusters_First_sequences_sorted: Dictionary of first sequence clusters.
+    - combined_pangenome_clusters_Second_sequences: Dictionary of second sequence clusters.
+    """
     # Create output directory if it doesn't exist
     if not os.path.exists(output_dir):
         os.makedirs(output_dir)
-    for key_prefix in key_order:
-        for key, values in cores.items():
-            if any(part in options.write_groups.split(',') for part in key.split('_')):
-                if key.startswith(key_prefix):
-                    for value in values:
-                        output_filename = f"{key}_{value}.fasta"
-                        if 'First' in key_prefix:
-                            sequences_to_write = pangenome_clusters_First_sequences_sorted[value]
-                        else: # combined_pangenome_clusters_Second_sequences is None if reclustered isn't being used
-                            sequences_to_write = combined_pangenome_clusters_Second_sequences[value]
-                            # Write sequences to output file that are in the sequences dictionary
-                        with open(os.path.join(output_dir, output_filename), 'w') as outfile:
-                            for header in sequences_to_write:
-                                if header in sequences:
-                                    outfile.write(f">{header}\n")
-                                    wrapped_sequence = wrap_sequence(sequences[header])
-                                    outfile.write(f"{wrapped_sequence}\n")
-                                else:
-                                    if options.verbose == True:
-                                        print("Sequence " + header + " Not found in original_fasta file.")
+
+    combined_fasta_filename = os.path.join(output_dir, "combined_group_sequences.fasta")
+
+    # Open combined FASTA file for writing all sequences
+    with open(combined_fasta_filename, 'w') as combined_fasta:
+        for key_prefix in key_order:
+            for key, values in cores.items():
+                if any(part in options.write_groups.split(',') for part in key.split('_')):
+                    if key.startswith(key_prefix):
+                        for value in values:
+                            output_filename = f"{key}_{value}.fasta"
+                            if 'First' in key_prefix:
+                                sequences_to_write = pangenome_clusters_First_sequences_sorted[value]
+                            else:
+                                sequences_to_write = combined_pangenome_clusters_Second_sequences[value]
+
+                            # Write individual FASTA file
+                            with open(os.path.join(output_dir, output_filename), 'w') as outfile:
+                                for header in sequences_to_write:
+                                    if header in sequences:
+                                        sequence = sequences[header]
+                                        outfile.write(f">{header}\n")
+                                        wrapped_sequence = wrap_sequence(sequence)
+                                        outfile.write(f"{wrapped_sequence}\n")
+
+                                        # Also write to the combined FASTA file
+                                        combined_fasta.write(f">Group_{value}|{header}\n")
+                                        combined_fasta.write(f"{wrapped_sequence}\n")
+                                    else:
+                                        if options.verbose:
+                                            print(f"Sequence {header} not found in original_fasta file.")
+
+    print(f"Combined FASTA file saved to: {combined_fasta_filename}")
+
 
 def process_gene_families(options, directory, output_file):
     """Process each gene family file to select the longest sequence per genome and concatenate aligned sequences."""

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyamilySeq
-Version: 0.7.0
+Version: 0.8.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
@@ -58,7 +58,7 @@ Escherichia_coli_110957|ENSB:TIZS9kbTvShDvyX	Escherichia_coli_110957|ENSB:TIZS9k
 ```
 ### Example output:
 ```
-Running PyamilySeq v0.7.0
+Running PyamilySeq v0.8.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.7.0
+Running PyamilySeq v0.8.0
 Calculating Groups
 Genus Groups:
 First_genera_1:	28549
@@ -98,37 +98,36 @@ Please report any issues to: https://github.com/NickJD/PyamilySeq/issues
 ### Reclustering can be used to see where additional sequences/genes lay in relation to a contemporary pangenome/gene grouping.
 ```
 PyamilySeq -run_mode Partial -group_mode Species -clustering_format CD-HIT -output_dir .../test_data/species/CD-HIT/testing 
--cluster_file .../test_data/species/CD-HIT/E-coli_extracted_cds_cd-hit_90_60.clstr -gpa 
--reclustered .../test_data/species/CD-HIT/E-coli_extracted_cds_cd-hit_90_60_And_StORFs_cds_90_60.clstr
+-cluster_file .../test_data/species/CD-HIT/E-coli_extracted_cds_cd-hit_80_60.clstr -gpa 
+-reclustered .../test_data/species/CD-HIT/E-coli_extracted_cds_cd-hit_80_60_And_StORFs_cds_80_60.clstr
 ```
 #### As can be seen below, the additional sequences recovered by the StORF-Reporter annotation tool have 'extended' contemporary or created entirely new gene groups. 'First' corresponds to the groups identified from the first clustering round and 'Second' for the second. In 'reclustering' mode, First_core_# groups are unaffected thus retaining the initial grouping information. 
 ```commandline
-Running PyamilySeq v0.7.0
 Calculating Groups
 Gene Groups:
-First_core_99: 69
-First_core_95: 1002
-First_core_15: 4716
-First_core_0: 37960
-extended_core_99: 6
-extended_core_95: 73
-extended_core_15: 331
-extended_core_0: 582
-combined_core_99: 4
-combined_core_95: 88
-combined_core_15: 455
-combined_core_0: 228
+First_core_99: 587
+First_core_95: 1529
+First_core_15: 3708
+First_core_0: 29992
+extended_core_99: 29
+extended_core_95: 67
+extended_core_15: 431
+extended_core_0: 1331
+combined_core_99: 2
+combined_core_95: 4
+combined_core_15: 5
+combined_core_0: 4
 Second_core_99: 0
-Second_core_95: 5
-Second_core_15: 254
-Second_core_0: 3714
-only_Second_core_99: 6
-only_Second_core_95: 364
-only_Second_core_15: 3950
-only_Second_core_0: 31269
-Total Number of First Gene Groups (Including Singletons): 43747
-Total Number of Second Gene Groups (Including Singletons): 66525
-Total Number of First Gene Groups That Had Additional Second Sequences But Not New Genomes: 9593
+Second_core_95: 6
+Second_core_15: 172
+Second_core_0: 1825
+only_Second_core_99: 53
+only_Second_core_95: 493
+only_Second_core_15: 3806
+only_Second_core_0: 27569
+Total Number of First Gene Groups (Including Singletons): 35816
+Total Number of Second Gene Groups (Including Singletons): 67728
+Total Number of First Gene Groups That Had Additional Second Sequences But Not New Genomes: 136
 Outputting gene_presence_absence file
 Thank you for using PyamilySeq -- A detailed user manual can be found at https://github.com/NickJD/PyamilySeq
 Please report any issues to: https://github.com/NickJD/PyamilySeq/issues
@@ -138,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.7.0
+Running PyamilySeq v0.8.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.7.0: A tool that groups genes into unique clusters.
+PyamilySeq v0.8.0: A tool that groups genes into unique clusters.
 
 options:
   -h, --help            show this help message and exit
@@ -198,9 +197,9 @@ 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 Partialrun mode.
+                        group levels at which to output "-w 99,95" - Must provide FASTA file with -original_fasta in Partial run mode.
   -original_fasta ORIGINAL_FASTA
-                        FASTA file to use in conjunction with "-w" or "-con" when running in Partial Mode.
+                        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
 
@@ -222,7 +221,7 @@ Seq-Combiner -input_dir .../test_data/genomes -name_split _combined.gff3 -output
 ```
 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.7.0: A tool to extract sequences from GFF/FASTA files.
+Seq-Combiner v0.8.0: A tool to extract sequences from GFF/FASTA files.
 
 options:
   -h, --help            show this help message and exit
@@ -248,4 +247,38 @@ Misc Arguments:
 
 
 ```
+
+### Group-Splitter menu: 
+
+```
+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: v0.8.0: A tool to split "paralogous" groups identified by PyamilySeq.
+
+options:
+  -h, --help            show this help message and exit
+
+Required Arguments:
+  -input_fasta INPUT_FASTA
+                        Input FASTA file containing gene groups.
+  -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
+                        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)
+  -verbose              Print verbose output.
+  -delete_temp_files    Delete all temporary files after processing.
+
+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.8.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+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,,

{PyamilySeq-0.7.0.dist-info → PyamilySeq-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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

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

PyamilySeq-0.7.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-PyamilySeq/Constants.py,sha256=RSX5-UuBXOrbEv3ETN415RwqoB6WmNe5eD-p7L15CJA,31
-PyamilySeq/PyamilySeq.py,sha256=wmdOVxxRKqsamsEWgnVVCYETUaYOEQQVYERpClrg4Zw,15203
-PyamilySeq/PyamilySeq_Genus.py,sha256=ZjD61mTW7NgmsfGfFVEXeIZoSCha9PaLtMPnqdTtacU,12413
-PyamilySeq/PyamilySeq_Species.py,sha256=WL6pu8hlGpnemcpu1tLFmlUlPd4vJpQSW4Om5Hclu_k,14438
-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=-0OZxmX96kOTzms8gnbFBvc5DL6NsqNHNpLpQ4UjNk8,15726
-PyamilySeq-0.7.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-PyamilySeq-0.7.0.dist-info/METADATA,sha256=JDhA1JdFaESNwtqzWjRgaA92lrmVFNJWQZUonHgJuvA,13105
-PyamilySeq-0.7.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-PyamilySeq-0.7.0.dist-info/entry_points.txt,sha256=QtXD1tmnLvRAkIpGWZgXm1lfLH8GGeCwxmgoHZaTp98,102
-PyamilySeq-0.7.0.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
-PyamilySeq-0.7.0.dist-info/RECORD,,