PyamilySeq 0.7.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

PyamilySeq/Constants.py

@@ -1,2 +1,2 @@
-PyamilySeq_Version = 'v0.7.1'
+PyamilySeq_Version = 'v0.8.1'
 

PyamilySeq/Group_Splitter.py

@@ -0,0 +1,350 @@
+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 = extract_identity(line)
+
+                    elif '*' in line:
+                        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
+
+
+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"{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)
+
+                # 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):
+                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('-sequence_type', action='store', dest='sequence_type', default='DNA',choices=['AA', 'DNA'],
+                          help='Default - DNA: Are groups "DNA" or "AA" sequences?',
+                          required=False)
+    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('-no_delete_temp_files', action='store_false', dest='delete_temp_files',
+                          help='Default: 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)
+
+    if options.sequence_type == 'DNA':
+        clustering_mode = 'cd-hit-est'
+    else:
+        clustering_mode = 'cd-hit'
+
+    separate_groups(options.input_fasta, options, clustering_mode)
+
+    print("Done")
+
+
+if __name__ == "__main__":
+    main()

PyamilySeq/PyamilySeq.py

@@ -27,7 +27,7 @@ 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",
         '-sc', "1",
@@ -41,7 +41,6 @@ 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.')
-    vparser = argparse.ArgumentParser()
     ### Required Arguments
     required = parser.add_argument_group('Required Arguments')
     required.add_argument('-run_mode', action='store', dest='run_mode', choices=['Full','Partial'],
@@ -85,8 +84,8 @@ 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
@@ -125,28 +124,19 @@ 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
     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)
-
-    ### Version Arguments
-    version = vparser.add_argument_group('Version')
-    version.add_argument('-v', action='store_true', dest='version',
+    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)
 
-
-
-    args, unknown = vparser.parse_known_args()
-
-    if args.version == True:
-        sys.exit("PyamilySeq version: "+PyamilySeq_Version)
-
     options = parser.parse_args()
 
     ### Checking all required parameters are provided by user #!!# Doesn't seem to work
@@ -265,6 +255,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
@@ -283,6 +274,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
@@ -299,5 +291,5 @@ def main():
           "Please report any issues to: https://github.com/NickJD/PyamilySeq/issues\n#####")
 
 if __name__ == "__main__":
-    #print("Running PyamilySeq "+PyamilySeq_Version)
+    print("Running PyamilySeq "+PyamilySeq_Version)
     main()

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,8 @@ import glob
 import collections
 from tempfile import NamedTemporaryFile
 import sys
+from line_profiler_pycharm import profile
+import re
 
 
 ################### We are currently fixed using Table 11
@@ -30,6 +32,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
@@ -49,12 +111,23 @@ 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 regular expressions to capture the percentage value at the end of the line
+    match = re.search(r'at ([-+]*)(\d+\.\d+)%', clustered_info)
+
+    if match:
+        percent_identity = float(match.group(2))  # 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):
@@ -111,14 +184,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
@@ -265,30 +339,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."""
@@ -297,7 +398,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
@@ -307,13 +408,15 @@ 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
             aligned_sequences = read_fasta(aligned_file)
             for genome, aligned_seq in aligned_sequences.items():
                 genome_name = genome.split('|')[0]
+                if 'Group' in genome_name:
+                    print(2)
                 if genome_name not in concatenated_sequences:
                     concatenated_sequences[genome_name] = ""
                 concatenated_sequences[genome_name] += aligned_seq

{PyamilySeq-0.7.1.dist-info → PyamilySeq-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyamilySeq
-Version: 0.7.1
+Version: 0.8.1
 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.1
+Running PyamilySeq v0.8.1
 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.1
+Running PyamilySeq v0.8.1
 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.7.1
+Running PyamilySeq v0.8.1
 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.1: A tool that groups genes into unique clusters.
+PyamilySeq v0.8.1: 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
@@ -221,7 +222,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.1: A tool to extract sequences from GFF/FASTA files.
+Seq-Combiner v0.8.1: A tool to extract sequences from GFF/FASTA files.
 
 options:
   -h, --help            show this help message and exit
@@ -247,4 +248,40 @@ 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.1: 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.
+  -sequence_type {AA,DNA}
+                        Default - DNA: Are groups "DNA" or "AA" sequences?
+  -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.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+PyamilySeq/Constants.py,sha256=J_jZheqHCbmFVCLrY8nMe4T5VZQOQ7PbT_HmYSi58WM,31
+PyamilySeq/Group_Splitter.py,sha256=wrz-vcQ2gJ40MLLczFY8te35_uYrOBuh2v-fJSIVsWo,15578
+PyamilySeq/PyamilySeq.py,sha256=OAtz6b7dnvA-Qg0dnf2JXImiOtsDrDfVit7Q6DFbuPU,15265
+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=vjPSIua4E72JTWlzH4CUaRcR-Z6Nr-RQ9N_92tfZI_w,19686
+PyamilySeq-0.8.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+PyamilySeq-0.8.1.dist-info/METADATA,sha256=weIjFQkc7ggqkPlPkSA5an8eFiUzhDyxGl9t7-rJPsA,14555
+PyamilySeq-0.8.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+PyamilySeq-0.8.1.dist-info/entry_points.txt,sha256=15BsozBN6vRWvZeQon05dY4YQT7DqP5i2TUqFWRGCvc,150
+PyamilySeq-0.8.1.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
+PyamilySeq-0.8.1.dist-info/RECORD,,

{PyamilySeq-0.7.1.dist-info → PyamilySeq-0.8.1.dist-info}/WHEEL

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

{PyamilySeq-0.7.1.dist-info → PyamilySeq-0.8.1.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.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-PyamilySeq/Constants.py,sha256=4MNcQLwJguoC9fHBLbreAe-GNgNvtzYrF0MBM6BFY_s,31
-PyamilySeq/PyamilySeq.py,sha256=RbM6G1yU64jlb9r7QRry1vw5mQsxndM6TrvMvq3BVik,15466
-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.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-PyamilySeq-0.7.1.dist-info/METADATA,sha256=IpbThlfEmO-S8Nl617eQB64Xzu9GJDz19L4Jhx7lwGY,13076
-PyamilySeq-0.7.1.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-PyamilySeq-0.7.1.dist-info/entry_points.txt,sha256=QtXD1tmnLvRAkIpGWZgXm1lfLH8GGeCwxmgoHZaTp98,102
-PyamilySeq-0.7.1.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
-PyamilySeq-0.7.1.dist-info/RECORD,,