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

PyamilySeq/clusterings.py

@@ -1,25 +1,26 @@
-import subprocess
-import shutil
-import os
-import glob
+
 import sys
 import copy
 from collections import OrderedDict
 from collections import defaultdict
+from collections import Counter
 
 def cluster_CDHIT(options, splitter):
     First_in = open(options.clusters, 'r')
     clusters = OrderedDict()
     pangenome_clusters_First = OrderedDict()
+    pangenome_clusters_First_genomes = OrderedDict()
     pangenome_clusters_First_sequences = OrderedDict()
     first = True
     taxa_dict = defaultdict(int)
     reps = OrderedDict()
+    tmp_genomes = None
     ## Load in all data for easier reuse later
     for line in First_in:
-        if '>Cluster 7575' in line:
-            print()
         if line.startswith('>'):
+            if tmp_genomes != None:
+                pangenome_clusters_First_genomes[rep] = tmp_genomes
+            tmp_genomes = []
             if first == False:
                 cluster_size = len(clusters[cluster_id])
                 reps.update({rep: [cluster_size, len(pangenome_clusters_First[cluster_id])]})
@@ -29,7 +30,6 @@ def cluster_CDHIT(options, splitter):
             clusters.update({cluster_id: []})
             pangenome_clusters_First.update({cluster_id: []})
             pangenome_clusters_First_sequences.update({cluster_id: []})
-
             first = False
         else:
             clustered = line.split('\t')[1]
@@ -45,32 +45,46 @@ def cluster_CDHIT(options, splitter):
                 clustered_taxa = clustered.split(splitter)[0]
                 if clustered_taxa not in pangenome_clusters_First[cluster_id]:
                     pangenome_clusters_First[cluster_id].append(clustered_taxa)
+                    tmp_genomes.append(clustered_taxa)
                 pangenome_clusters_First_sequences[cluster_id].append(clustered)
-    return taxa_dict, pangenome_clusters_First, pangenome_clusters_First_sequences, reps
+
+    pangenome_clusters_First_genomes[rep] = tmp_genomes
+
+    return taxa_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps
 
 
 
 #@profile
-def combined_clustering_counting(options, pangenome_clusters_First, reps, combined_pangenome_clusters_First_Second_clustered, splitter):
+def combined_clustering_counting(options, pangenome_clusters_First, reps, combined_pangenome_clusters_First_Second_clustered, pangenome_clusters_First_genomes, splitter):
     num_clustered_First = defaultdict(list)
     pangenome_clusters_Type = copy.deepcopy(pangenome_clusters_First)
     list_of_reps = list(reps.keys())
-    for cluster, pep_genomes in pangenome_clusters_First.items():
+    for cluster, First_genomes in pangenome_clusters_First.items():
         rep = list_of_reps[int(cluster)]  # get the rep of the current pep cluster
         Com_PEP_Genomes = 0
         Seconds = 0
         seen_Seconds = []
         added_Second_genomes = 0
-        try:  # get the cluster from the storf clusters which contains this rep
-            clustered_combined = combined_pangenome_clusters_First_Second_clustered[rep]  # Not true clusters - I put a PEP as key myself
+        temp_pep_genomes = copy.deepcopy(First_genomes)
+        try:  # get the cluster from the Second clusters which contains this rep
+            clustered_combined = combined_pangenome_clusters_First_Second_clustered[rep]
+            #We have to do this to correctly account for Seconds grouping multiple original First clusters
+            for clust in clustered_combined:
+                ### Get the original clustered genomes first:
+                if options.sequence_tag not in clust:
+                    original_clustered_genomes = pangenome_clusters_First_genomes[clust]
+                    for genome in original_clustered_genomes:
+                        if genome not in temp_pep_genomes:
+                            temp_pep_genomes.append(genome)
+
             seen_clust_Genomes = []
-            num_clustered_First[cluster].append(rep + '_' + str(len(pep_genomes)))
+            num_clustered_First[cluster].append(rep + '_' + str(len(First_genomes)))
             for clust in clustered_combined:
                 if options.sequence_tag not in clust:  # Not good enough at the moment
                     clust_Genome = clust.split(splitter)[0]
                     if clust_Genome not in seen_clust_Genomes:
                         seen_clust_Genomes.append(clust_Genome)
-                        if clust_Genome not in pep_genomes:
+                        if clust_Genome not in First_genomes:
                             Com_PEP_Genomes += 1
                     num_clustered_First[cluster].append(clust + '_' + str(reps[clust][1]))
                 elif options.sequence_tag in clust:
@@ -80,23 +94,38 @@ def combined_clustering_counting(options, pangenome_clusters_First, reps, combin
                         seen_Seconds.append(clust_Genome)
                     if clust_Genome not in seen_clust_Genomes:
                         seen_clust_Genomes.append(clust_Genome)
-                        if clust_Genome not in pep_genomes:
+                        if clust_Genome not in temp_pep_genomes:
                             added_Second_genomes += 1
+                            temp_pep_genomes.append(clust_Genome)
                 else:
                     sys.exit("Error: looking for sequence_tag")
 
             size_of_pep_clusters = []
-            peps = num_clustered_First[cluster]
-            for pep in peps:
-                pep = pep.rsplit('_', 1)
-                size_of_pep_clusters.append(int(pep[1]))
-            pangenome_clusters_Type[cluster] = [len(num_clustered_First[cluster]), sum(size_of_pep_clusters),
+            genomes = num_clustered_First[cluster]
+
+
+            if len(genomes) > 1: #!!# So that we don't double count - This still needs to account for whether the same genome/genus is present however. Probably need to unique ti
+               collecting_genomes = []
+               for genome in genomes:
+                   genome = genome.rsplit('_', 1)
+                   collecting_genomes.append(pangenome_clusters_First[str(list_of_reps.index(genome[0]))])
+                   size_of_pep_clusters.append([str(list_of_reps.index(genome[0])) + ':' + genome[1]])
+               flattened_list = [item for sublist in collecting_genomes for item in sublist]
+               element_counts = Counter(flattened_list)
+               unique_elements = [element for element, count in element_counts.items() if count == 1]
+               sum_size_of_pep_clusters = len(unique_elements)
+            else:
+                genome = genomes[0].rsplit('_', 1)
+                size_of_pep_clusters.append([str(list_of_reps.index(genome[0]))+':'+genome[1]])
+                sum_size_of_pep_clusters = int(genome[1])
+
+            pangenome_clusters_Type[cluster] = [len(num_clustered_First[cluster]), sum_size_of_pep_clusters,
                                                 size_of_pep_clusters, added_Second_genomes, Seconds, len(seen_Seconds)]
 
         except KeyError:
             ###Singleton
-            num_pep_genomes = [len(pep_genomes)]
-            pangenome_clusters_Type[cluster] = [1, len(pep_genomes), num_pep_genomes, added_Second_genomes, Seconds,
+            num_First_genomes = [[str(cluster)+':'+str(len(First_genomes))]]
+            pangenome_clusters_Type[cluster] = [1, len(First_genomes), num_First_genomes, added_Second_genomes, Seconds,
                                                 len(seen_Seconds)]
     # pangenome_clusters_Type = [Number of First clustered genomes or genera, Size of the cluster, Ditto, Added Seconds,Number of Seconds,Unique Seconds ]
     return pangenome_clusters_Type
@@ -112,20 +141,21 @@ def single_clustering_counting(pangenome_clusters_First, reps):
         rep = list_of_reps[int(cluster)]  # get the rep of the current pep cluster
 
         try:  # get the cluster from the storf clusters which contains this rep
-            num_clustered_First[cluster].append(rep + '_' + str(len(First_taxa)))
+            num_clustered_First[str(cluster)].append(rep + '_' + str(len(First_taxa)))
             size_of_First_clusters = []
-            Firsts = num_clustered_First[cluster]
+            Firsts = num_clustered_First[str(cluster)]
             for First in Firsts:
                 First = First.rsplit('_', 1)
                 size_of_First_clusters.append(int(First[1]))
                 recorded_First.append(First[0])
+            num_First_genomes = [[str(cluster) + ':' + str(len(First_taxa))]]
             pangenome_clusters_Type[cluster] = [len(num_clustered_First[cluster]), sum(size_of_First_clusters),
-                                                size_of_First_clusters, 0, 0, 0]
+                                                num_First_genomes, 0, 0, 0]
 
         except KeyError:
             ###Singleton
-            num_First_taxa = [len(First_taxa)]
-            pangenome_clusters_Type[cluster] = [1, len(First_taxa), num_First_taxa, 0, 0, 0]
+            num_First_genomes = [[str(cluster)+':'+str(len(First_taxa))]]
+            pangenome_clusters_Type[cluster] = [1, len(First_taxa), num_First_genomes, 0, 0, 0]
 
     # pangenome_clusters_Type = [Number of First clustered genomes or genera, Size of the cluster, Ditto, 0,0,0 ]
     return pangenome_clusters_Type
@@ -158,7 +188,7 @@ def combined_clustering_CDHIT(options, taxa_dict, splitter):
                         else:
                             already_seen_PEP.append(pep)
                 if len(combined_pangenome_clusters_Second_sequences[cluster_id]) > 0 and len(combined_pangenome_clusters_First_sequences[cluster_id]) > 0:
-                    if len(combined_pangenome_clusters_First_sequences[cluster_id]) > 1:  # If we have clustered >1 PEP family, we need to record 1 as key and all others are val
+                    if len(combined_pangenome_clusters_First_sequences[cluster_id]) > 1:  # If we have clustered >1 First family, we need to record 1 as key and all others are val
                         all_but_first = combined_pangenome_clusters_First_sequences[cluster_id][1:]
                         storfs_clustered = combined_pangenome_clusters_Second_sequences[cluster_id]
                         VALUE = all_but_first + storfs_clustered
@@ -194,13 +224,13 @@ def combined_clustering_CDHIT(options, taxa_dict, splitter):
                     combined_pangenome_clusters_Second_sequences[cluster_id].append(clustered)
                 else:
                     if cluster_id not in not_Second_only_cluster_ids:
-                        not_Second_only_cluster_ids.append(cluster_id)  # Tell us which StORF_Reporter clustered are unmatched to a PEP
+                        not_Second_only_cluster_ids.append(cluster_id)
                     if clustered_taxa not in combined_pangenome_clusters_First[cluster_id]:
                         combined_pangenome_clusters_First[cluster_id].append(clustered_taxa)
                     combined_pangenome_clusters_First_sequences[cluster_id].append(clustered)
 
 
-    return combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids, combined_pangenome_clusters_Second
+    return combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids, combined_pangenome_clusters_Second, combined_pangenome_clusters_Second_sequences
 
 
 def cluster_EdgeList(options,splitter):
@@ -213,37 +243,45 @@ def cluster_EdgeList(options,splitter):
     first = True
     First_in = open(options.clusters, 'r')
     pangenome_clusters_First = OrderedDict()
+    pangenome_clusters_First_genomes = OrderedDict()
     pangenome_clusters_First_sequences = OrderedDict()
     taxa_dict = defaultdict(int)
     reps = OrderedDict()
+    tmp_genomes = None
     for line in First_in:
         rep, child = line.strip().split(separator)
         child_taxa = child.split(splitter)[0]  # Extracting the genome identifier from the child sequence
         # Counting occurrences of genomes
         taxa_dict[child_taxa] += 1
         if first == True:
-            pangenome_clusters_First[0] = []
-            pangenome_clusters_First_sequences[0] = []
+            pangenome_clusters_First['0'] = []
+            pangenome_clusters_First_sequences['0'] = []
             first = False
+            tmp_genomes = []
 
         if rep != last_rep and last_rep != '':
+            pangenome_clusters_First_genomes[rep] = tmp_genomes
+            tmp_genomes = []
             cluster_id +=1
-            pangenome_clusters_First[cluster_id] = []
-            pangenome_clusters_First_sequences[cluster_id] = []
-            cluster_size = len(pangenome_clusters_First_sequences[cluster_id-1])
-            reps.update({last_rep: [cluster_size, len(pangenome_clusters_First[cluster_id-1])]})
-            pangenome_clusters_First[cluster_id] = []
-            pangenome_clusters_First_sequences[cluster_id] = []
-        if child_taxa not in pangenome_clusters_First[cluster_id]:
-            pangenome_clusters_First[cluster_id].append(child_taxa)
-
-        pangenome_clusters_First_sequences[cluster_id].append(child)
+            pangenome_clusters_First[str(cluster_id)] = []
+            pangenome_clusters_First_sequences[str(cluster_id)] = []
+            cluster_size = len(pangenome_clusters_First_sequences[str(cluster_id-1)])
+            reps.update({last_rep: [cluster_size, len(pangenome_clusters_First[str(cluster_id-1)])]})
+            pangenome_clusters_First[str(cluster_id)] = []
+            pangenome_clusters_First_sequences[str(cluster_id)] = []
+        if child_taxa not in pangenome_clusters_First[str(cluster_id)]:
+            pangenome_clusters_First[str(cluster_id)].append(child_taxa)
+            tmp_genomes.append(child_taxa)
+
+        pangenome_clusters_First_sequences[str(cluster_id)].append(child)
         last_rep = rep
-        cluster_size = len(pangenome_clusters_First_sequences[cluster_id])
-        reps.update({rep: [cluster_size, len(pangenome_clusters_First[cluster_id])]})
+        cluster_size = len(pangenome_clusters_First_sequences[str(cluster_id)])
+        reps.update({rep: [cluster_size, len(pangenome_clusters_First[str(cluster_id)])]})
 
+    #!!# May not be needed below
+    pangenome_clusters_First_genomes[rep] = tmp_genomes
 
-    return taxa_dict, pangenome_clusters_First, pangenome_clusters_First_sequences, reps
+    return taxa_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps
 
 
 def combined_clustering_Edge_List(options, splitter):
@@ -271,54 +309,54 @@ def combined_clustering_Edge_List(options, splitter):
         child_taxa = child.split(splitter)[0]  # Extracting the genome identifier from the child sequence
 
         if first == True:
-            Combined_clusters.update({cluster_id: []})
-            combined_pangenome_clusters_First.update({cluster_id: []})
-            combined_pangenome_clusters_First_sequences.update({cluster_id: []})
-            combined_pangenome_clusters_Second.update({cluster_id: []})
-            combined_pangenome_clusters_Second_sequences.update({cluster_id: []})
+            Combined_clusters.update({str(cluster_id): []})
+            combined_pangenome_clusters_First.update({str(cluster_id): []})
+            combined_pangenome_clusters_First_sequences.update({str(cluster_id): []})
+            combined_pangenome_clusters_Second.update({str(cluster_id): []})
+            combined_pangenome_clusters_Second_sequences.update({str(cluster_id): []})
             Combined_reps.update({rep: 0})
             first = False
 
         if first == False:
             if rep != last_rep and last_rep != '':
-                cluster_size = len(Combined_clusters[cluster_id])
+                cluster_size = len(Combined_clusters[str(cluster_id)])
                 Combined_reps.update({rep: cluster_size})
-                for pep in combined_pangenome_clusters_First_sequences[cluster_id]:
+                for pep in combined_pangenome_clusters_First_sequences[str(cluster_id)]:
                     if pep != []:
                         if pep in already_seen_PEP:
                             continue
                         else:
                             already_seen_PEP.append(pep)
-                if len(combined_pangenome_clusters_Second_sequences[cluster_id]) > 0 and len(combined_pangenome_clusters_First_sequences[cluster_id]) > 0:
-                    if len(combined_pangenome_clusters_First_sequences[cluster_id]) > 1:  # If we have clustered >1 PEP family, we need to record 1 as key and all others are val
-                        all_but_first = combined_pangenome_clusters_First_sequences[cluster_id][1:]
-                        storfs_clustered = combined_pangenome_clusters_Second_sequences[cluster_id]
+                if len(combined_pangenome_clusters_Second_sequences[str(cluster_id)]) > 0 and len(combined_pangenome_clusters_First_sequences[str(cluster_id)]) > 0:
+                    if len(combined_pangenome_clusters_First_sequences[str(cluster_id)]) > 1:  # If we have clustered >1 PEP family, we need to record 1 as key and all others are val
+                        all_but_first = combined_pangenome_clusters_First_sequences[str(cluster_id)][1:]
+                        storfs_clustered = combined_pangenome_clusters_Second_sequences[str(cluster_id)]
                         VALUE = all_but_first + storfs_clustered
                     else:
-                        VALUE = combined_pangenome_clusters_Second_sequences[cluster_id]
-                    KEY = combined_pangenome_clusters_First_sequences[cluster_id][0]
+                        VALUE = combined_pangenome_clusters_Second_sequences[str(cluster_id)]
+                    KEY = combined_pangenome_clusters_First_sequences[str(cluster_id)][0]
                     combined_pangenome_clusters_First_Second_clustered.update({KEY: VALUE})
 
                 cluster_id += 1
-                Combined_clusters.update({cluster_id: []})
-                combined_pangenome_clusters_First.update({cluster_id: []})
-                combined_pangenome_clusters_First_sequences.update({cluster_id: []})
-                combined_pangenome_clusters_Second.update({cluster_id: []})
-                combined_pangenome_clusters_Second_sequences.update({cluster_id: []})
+                Combined_clusters.update({str(cluster_id): []})
+                combined_pangenome_clusters_First.update({str(cluster_id): []})
+                combined_pangenome_clusters_First_sequences.update({str(cluster_id): []})
+                combined_pangenome_clusters_Second.update({str(cluster_id): []})
+                combined_pangenome_clusters_Second_sequences.update({str(cluster_id): []})
                 Combined_reps.update({rep: 0})
 
-        Combined_clusters[cluster_id].append(child)
+        Combined_clusters[str(cluster_id)].append(child)
         if options.sequence_tag in line:
-            if child_taxa not in combined_pangenome_clusters_Second[cluster_id]:
-                combined_pangenome_clusters_Second[cluster_id].append(child_taxa)
-            combined_pangenome_clusters_Second_sequences[cluster_id].append(child)
+            if child_taxa not in combined_pangenome_clusters_Second[str(cluster_id)]:
+                combined_pangenome_clusters_Second[str(cluster_id)].append(child_taxa)
+            combined_pangenome_clusters_Second_sequences[str(cluster_id)].append(child)
         else:
-            if cluster_id not in not_Second_only_cluster_ids:
-                not_Second_only_cluster_ids.append(cluster_id)  # Tell us which StORF_Reporter clustered are unmatched to a PEP
-            if child_taxa not in combined_pangenome_clusters_First[cluster_id]:
-                combined_pangenome_clusters_First[cluster_id].append(child_taxa)
-            combined_pangenome_clusters_First_sequences[cluster_id].append(child)
+            if str(cluster_id) not in not_Second_only_cluster_ids:
+                not_Second_only_cluster_ids.append(str(cluster_id))  # Tell us which StORF_Reporter clustered are unmatched to a PEP
+            if child_taxa not in combined_pangenome_clusters_First[str(cluster_id)]:
+                combined_pangenome_clusters_First[str(cluster_id)].append(child_taxa)
+            combined_pangenome_clusters_First_sequences[str(cluster_id)].append(child)
 
         last_rep = rep
 
-    return combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids, combined_pangenome_clusters_Second
+    return combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids, combined_pangenome_clusters_Second, combined_pangenome_clusters_Second_sequences

PyamilySeq/utils.py

@@ -7,6 +7,29 @@ from tempfile import NamedTemporaryFile
 import sys
 
 
+################### We are currently fixed using Table 11
+gencode = {
+      'ATA':'I', 'ATC':'I', 'ATT':'I', 'ATG':'M',
+      'ACA':'T', 'ACC':'T', 'ACG':'T', 'ACT':'T',
+      'AAC':'N', 'AAT':'N', 'AAA':'K', 'AAG':'K',
+      'AGC':'S', 'AGT':'S', 'AGA':'R', 'AGG':'R',
+      'CTA':'L', 'CTC':'L', 'CTG':'L', 'CTT':'L',
+      'CCA':'P', 'CCC':'P', 'CCG':'P', 'CCT':'P',
+      'CAC':'H', 'CAT':'H', 'CAA':'Q', 'CAG':'Q',
+      'CGA':'R', 'CGC':'R', 'CGG':'R', 'CGT':'R',
+      'GTA':'V', 'GTC':'V', 'GTG':'V', 'GTT':'V',
+      'GCA':'A', 'GCC':'A', 'GCG':'A', 'GCT':'A',
+      'GAC':'D', 'GAT':'D', 'GAA':'E', 'GAG':'E',
+      'GGA':'G', 'GGC':'G', 'GGG':'G', 'GGT':'G',
+      'TCA':'S', 'TCC':'S', 'TCG':'S', 'TCT':'S',
+      'TTC':'F', 'TTT':'F', 'TTA':'L', 'TTG':'L',
+      'TAC':'Y', 'TAT':'Y', 'TAA':'*', 'TAG':'*',
+      'TGC':'C', 'TGT':'C', 'TGA':'*', 'TGG':'W'}
+
+def translate_frame(sequence):
+    translate = ''.join([gencode.get(sequence[3 * i:3 * i + 3], 'X') for i in range(len(sequence) // 3)])
+    return translate
+
 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
@@ -75,7 +98,7 @@ def select_longest_gene(sequences):
 
 
 def run_mafft_on_sequences(options, sequences, output_file):
-    print("Conducting MAFFT alignment.")
+    #print("Conducting MAFFT alignment.")
     """Run mafft on the given sequences and write to output file."""
     # Create a temporary input file for mafft
     with NamedTemporaryFile('w', delete=False) as temp_input_file:
@@ -106,7 +129,7 @@ def run_mafft_on_sequences(options, sequences, output_file):
 
 
 
-def read_separate_files(input_dir, name_split, combined_out):
+def read_separate_files(input_dir, name_split, gene_ident, combined_out, translate):
     with open(combined_out, 'w') as combined_out_file:
         for gff_file in glob.glob(os.path.join(input_dir, '*' + name_split)):
             genome_name = os.path.basename(gff_file).split(name_split)[0]
@@ -121,7 +144,7 @@ def read_separate_files(input_dir, name_split, combined_out):
                 for line in lines:
                     line_data = line.split('\t')
                     if len(line_data) == 9:
-                        if line_data[2] == 'CDS':
+                        if any(gene_type in line_data[2] for gene_type in gene_ident):
                             contig = line_data[0]
                             feature = line_data[2]
                             strand = line_data[6]
@@ -158,12 +181,13 @@ def read_separate_files(input_dir, name_split, combined_out):
                             corrected_stop = max(len(fasta_dict[contig][0]) - int(start - 1), 1)
                             full_sequence = fasta_dict[contig][1]
                             cds_sequence = full_sequence[corrected_start:corrected_stop]
-
+                        if translate == True:
+                            cds_sequence = translate_frame(cds_sequence)
                         wrapped_sequence = '\n'.join([cds_sequence[i:i + 60] for i in range(0, len(cds_sequence), 60)])
                         combined_out_file.write(f">{genome_name}|{seq_id}\n{wrapped_sequence}\n")
 
 
-def read_combined_files(input_dir, name_split, combined_out):
+def read_combined_files(input_dir, name_split, gene_ident, combined_out, translate):
     with open(combined_out, 'w') as combined_out_file:
         for gff_file in glob.glob(os.path.join(input_dir, '*' + name_split)):
             genome_name = os.path.basename(gff_file).split(name_split)[0]
@@ -186,7 +210,7 @@ def read_combined_files(input_dir, name_split, combined_out):
                     else:
                         line_data = line.split('\t')
                         if len(line_data) == 9:
-                            if line_data[2] == 'CDS':
+                            if any(gene_type in line_data[2] for gene_type in gene_ident):
                                 contig = line_data[0]
                                 feature = line_data[2]
                                 strand = line_data[6]
@@ -215,5 +239,91 @@ def read_combined_files(input_dir, name_split, combined_out):
                                 full_sequence = fasta_dict[contig][1]
                                 cds_sequence = full_sequence[corrected_start:corrected_stop]
 
+                            if translate == True:
+                                cds_sequence = translate_frame(cds_sequence)
                             wrapped_sequence = '\n'.join([cds_sequence[i:i + 60] for i in range(0, len(cds_sequence), 60)])
-                            combined_out_file.write(f">{genome_name}|{seq_id}\n{wrapped_sequence}\n")
+                            combined_out_file.write(f">{genome_name}|{seq_id}\n{wrapped_sequence}\n")
+
+
+def read_fasta_files(input_dir, name_split, combined_out, translate):
+    with open(combined_out, 'w') as combined_out_file:
+        for fasta_file in glob.glob(os.path.join(input_dir, '*' + name_split)):
+            genome_name = os.path.basename(fasta_file).split(name_split)[0]
+            fasta_dict = collections.defaultdict(str)
+            with open(fasta_file, 'r') as file:
+                lines = file.readlines()
+                for line in lines:
+                    if line.startswith('>'):
+                        current_seq = line[1:].split()[0]
+                        fasta_dict[current_seq] = ''
+                    else:
+                        fasta_dict[current_seq] +=line.strip()
+                for id, seq in fasta_dict.items():
+                    if translate == True:
+                        seq = translate_frame(seq)
+                    wrapped_sequence = '\n'.join([seq[i:i + 60] for i in range(0, len(seq), 60)])
+                    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):
+    # 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.")
+
+def process_gene_families(options, directory, output_file):
+    """Process each gene family file to select the longest sequence per genome and concatenate aligned sequences."""
+    concatenated_sequences = {}
+    output_file = directory.replace('Gene_Families_Output',output_file)
+
+    # Iterate over each gene family file
+    for gene_file in os.listdir(directory):
+        if gene_file.endswith('.fasta'):
+            gene_path = os.path.join(directory, gene_file)
+
+            # Read sequences from the gene family file
+            sequences = read_fasta(gene_path)
+
+            # Select the longest sequence for each genome
+            longest_sequences = select_longest_gene(sequences)
+
+            # Run mafft on the longest sequences
+            aligned_file = f"{gene_file}_aligned.fasta"
+            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 genome_name not in concatenated_sequences:
+                    concatenated_sequences[genome_name] = ""
+                concatenated_sequences[genome_name] += aligned_seq
+
+            # Clean up aligned file
+            os.remove(aligned_file)
+
+    # Write the concatenated sequences to the output file
+    with open(output_file, 'w') as out:
+        for genome, sequence in concatenated_sequences.items():
+            out.write(f">{genome}\n")
+            wrapped_sequence = wrap_sequence(sequence, 60)
+            out.write(f"{wrapped_sequence}\n")