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

PyamilySeq/Constants.py

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

PyamilySeq/PyamilySeq.py

@@ -20,9 +20,9 @@ except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
 
 
 
-def run_cd_hit(input_file, clustering_output, options):
+def run_cd_hit(options, input_file, clustering_output, clustering_mode):
     cdhit_command = [
-        'cd-hit-est',
+        clustering_mode,
         '-i', input_file,
         '-o', clustering_output,
         '-c', str(options.pident),
@@ -33,14 +33,15 @@ def run_cd_hit(input_file, clustering_output, options):
         '-sc', "1",
         '-sf', "1"
     ]
-    if options.verbose == True:
+    if options.verbose != None:
         subprocess.run(cdhit_command)
     else:
         subprocess.run(cdhit_command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
 
 def main():
-    parser = argparse.ArgumentParser(description='PyamilySeq ' + PyamilySeq_Version + ': PyamilySeq Run Parameters.')
+    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'],
@@ -49,8 +50,8 @@ def main():
     required.add_argument('-group_mode', action='store', dest='group_type', choices=['Species', 'Genus'],
                           help='Group Mode: Should PyamilySeq be run in "Species" or "Genus" mode? ',
                           required=True)
-    required.add_argument("-clust_tool", action="store", dest="clust_tool", choices=['CD-HIT'],
-                          help="Clustering tool to use: CD-HIT, DIAMOND, BLAST or MMseqs2.",
+    required.add_argument("-clustering_format", action="store", dest="clustering_format", choices=['CD-HIT','TSV','CSV'],
+                          help="Clustering format to use: CD-HIT or TSV (MMseqs2, BLAST, DIAMOND) / CSV edge-list file (Node1\tNode2).",
                           required=True)
     required.add_argument("-output_dir", action="store", dest="output_dir",
                           help="Directory for all output files.",
@@ -67,6 +68,12 @@ def main():
     full_mode_args.add_argument("-name_split", action="store", dest="name_split",
                           help="substring used to split the filename and extract the genome name ('_combined.gff3' or '.gff').",
                           required=False)
+    full_mode_args.add_argument('-sequence_type', action='store', dest='sequence_type', default='DNA',choices=['AA', 'DNA'],
+                          help='Default - DNA: Should clustering be performed in "DNA" or "AA" mode?',
+                          required=False)
+    full_mode_args.add_argument('-gene_ident', action='store', dest='gene_ident', default='CDS',
+                          help='Identifier used for extraction of sequences such as "misc_RNA,gene,mRNA,CDS,rRNA,tRNA,tmRNA,CRISPR,ncRNA,regulatory_region,oriC,pseudo"',
+                          required=False)
     full_mode_args.add_argument("-pid", action="store", dest="pident", type=float, default=0.95,
                           help="Default 0.95: Pident threshold for clustering.",
                           required=False)
@@ -99,51 +106,67 @@ def main():
     grouping_args.add_argument('-core_groups', action="store", dest='core_groups', default="99,95,15",
                         help='Default - (\'99,95,15\'): Gene family groups to use for "Species" mode',
                         required=False)
+
     grouping_args.add_argument('-genus_groups', action="store", dest='genus_groups', default="1,2,3,4,5,6",
                         help='Default - (\'1,2,3,4,5,6\'): Gene family groups to use for "Genus" mode',
                         required=False)
 
     ###Output Arguments
     output_args = parser.add_argument_group('Output Parameters')
-    output_args.add_argument('-w', action="store", dest='write_families', default=None,
-                          help='Default - No output: Output sequences of identified families (provide levels at which to output "-w 99,95"'
-                               ' - Must provide FASTA file with -fasta',
+    output_args.add_argument('-w', action="store", dest='write_groups', default=None,
+                          help='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.',
                           required=False)
-    output_args.add_argument('-con', action="store", dest='con_core', default=None,
-                          help='Default - No output: Output aligned and concatinated sequences of identified families - used for MSA (provide levels at which to output "-w 99,95"'
-                               ' - Must provide FASTA file with -fasta',
+    output_args.add_argument('-a', action="store_true", dest='align_core', default=None,
+                          help='Default - No output: SLOW! (Only works for Species mode) Output aligned and concatinated sequences of identified groups -'
+                               'provide group levels at which to output "-w 99,95" - Must provide FASTA file with -original_fasta in Partial'
+                               'run mode.',
                           required=False)
     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', dest='gene_presence_absence_out', help='Default - False: If selected, a Roary formatted gene_presence_absence.csv will be created - Required for Coinfinder and other downstream tools',
-                        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',
+                          required=False)
 
     ### Misc Arguments
     misc = parser.add_argument_group('Misc')
-    misc.add_argument('-verbose', action='store', dest='verbose', default=False, type=eval, choices=[True, False],
-                        help='Default - False: Print out runtime messages',
+    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',
+
+    ### Version Arguments
+    version = vparser.add_argument_group('Version')
+    version.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
+    ### Checking all required parameters are provided by user #!!# Doesn't seem to work
     if options.run_mode == 'Full':
+
         if options.reclustered != None:
             sys.exit("Currently reclustering only works on Partial Mode.")
-        required_full_mode = [options.input_type, options.input_dir, options.name_split, options.clust_tool,
+        required_full_mode = [options.input_type, options.input_dir, options.name_split, options.clustering_format,
                               options.pident, options.len_diff]
         if all(required_full_mode):
             # Proceed with the Full mode
             pass
         else:
             missing_options = [opt for opt in
-                               ['input_type', 'input_dir', 'name_split', 'clust_tool', 'pident', 'len_diff'] if
+                               ['input_type', 'input_dir', 'name_split', 'clustering_format', 'pident', 'len_diff'] if
                                not options.__dict__[opt]]
             print(f"Missing required options for Full mode: {', '.join(missing_options)}")
+        if options.align_core != None:
+            if options.write_groups == None:
+                sys.exit('Must provide "-w" to output gene groups before alignment "-a" can be done.')
     elif options.run_mode == 'Partial':
         required_partial_mode = [options.cluster_file, ]
         if all(required_partial_mode):
@@ -154,33 +177,37 @@ def main():
                                ['cluster_file',] if
                                not options.__dict__[opt]]
             print(f"Missing required options for Partial mode: {', '.join(missing_options)}")
+        if options.align_core != None:
+            if options.write_groups == None or options.original_fasta == None:
+                sys.exit('Must provide "-w" and "-original_fasta" to output gene groups before alignment "-a" can be done.')
 
-    if options.clust_tool == 'CD-HIT':
+    if options.clustering_format == 'CD-HIT':
         clust_affix = '.clstr'
-    elif options.clust_tool == 'TSV':
+    elif options.clustering_format == 'TSV':
         clust_affix = '.tsv'
-    elif options.clust_tool == 'CSV':
+    elif options.clustering_format == 'CSV':
         clust_affix = '.csv'
 
 
 
+
     ###External tool checks:
     ##MAFFT
-    if options.con_core == True:
+    if options.align_core == True:
         if is_tool_installed('mafft'):
-            if options.verbose == True:
+            if options.verbose != None:
                 print("mafft is installed. Proceeding with alignment.")
         else:
             exit("mafft is not installed. Please install mafft to proceed.")
     ##CD-HIT
-    if options.clust_tool == 'CD-HIT' and options.run_mode == 'Full':
+    if options.clustering_format == 'CD-HIT' and options.run_mode == 'Full':
         if is_tool_installed('cd-hit'):
-            if options.verbose == True:
+            if options.verbose != None:
                 print("cd-hit is installed. Proceeding with clustering.")
         else:
             exit("cd-hit is not installed. Please install cd-hit to proceed.")
 
-    if options.write_families != None and options.original_fasta == False:
+    if options.write_groups != None and options.original_fasta == False:
         exit("-fasta must br provided if -w is used")
 
 
@@ -197,35 +224,48 @@ def main():
 
     output_path = os.path.abspath(options.output_dir)
     combined_out_file = os.path.join(output_path, "combined_sequences.fasta")
-    clustering_output = os.path.join(output_path, 'clustering_' + options.clust_tool)
+    clustering_output = os.path.join(output_path, 'clustering_' + options.clustering_format)
 
     if options.group_type == 'Species':
         options.core_groups = options.core_groups + ',0'
         groups_to_use = options.core_groups
-    else:
+    elif options.group_type == 'Genus':
         options.genus_groups = options.genus_groups + ',>'
         groups_to_use = options.genus_groups
+        if options.align_core != None:
+            sys.exit("-a align_core not a valid option in Genus mode.")
 
 
     if options.run_mode == 'Full':
+        if not os.path.exists(output_path):
+            os.makedirs(output_path)
+        if options.sequence_type == 'AA':
+            clustering_mode = 'cd-hit'
+            translate = True
+        elif options.sequence_type == 'DNA':
+            clustering_mode = 'cd-hit-est'
+            translate = False
         if options.input_type == 'separate':
-            read_separate_files(options.input_dir, options.name_split, combined_out_file)
+            read_separate_files(options.input_dir, options.name_split, options.gene_ident, combined_out_file, translate)
         else:
-            read_combined_files(options.input_dir, options.name_split, combined_out_file)
+            read_combined_files(options.input_dir, options.name_split, options.gene_ident, combined_out_file, translate)
 
-        run_cd_hit(combined_out_file, clustering_output, options)
+        if options.clustering_format == 'CD-HIT':
+            run_cd_hit(options, combined_out_file, clustering_output, clustering_mode)
 
         class clustering_options:
             def __init__(self):
-                self.cluster_format = options.clust_tool
+                self.run_mode = options.run_mode
+                self.cluster_format = options.clustering_format
+                self.sequence_type = options.sequence_type
                 self.reclustered = options.reclustered
                 self.sequence_tag = options.sequence_tag
                 self.core_groups = groups_to_use
                 self.clusters = clustering_output + clust_affix
                 self.output_dir = options.output_dir
                 self.gene_presence_absence_out = options.gene_presence_absence_out
-                self.write_families = options.write_families
-                self.con_core = options.con_core
+                self.write_groups = options.write_groups
+                self.align_core = options.align_core
                 self.fasta = combined_out_file
                 self.verbose = options.verbose
 
@@ -234,15 +274,16 @@ def main():
     elif options.run_mode == 'Partial':
         class clustering_options:
             def __init__(self):
-                self.cluster_format = options.clust_tool
+                self.run_mode = options.run_mode
+                self.cluster_format = options.clustering_format
                 self.reclustered = options.reclustered
                 self.sequence_tag = options.sequence_tag
                 self.core_groups = groups_to_use
                 self.clusters = options.cluster_file
                 self.output_dir = options.output_dir
                 self.gene_presence_absence_out = options.gene_presence_absence_out
-                self.write_families = options.write_families
-                self.con_core = options.con_core
+                self.write_groups = options.write_groups
+                self.align_core = options.align_core
                 self.fasta = options.original_fasta
                 self.verbose = options.verbose
 
@@ -258,4 +299,5 @@ def main():
           "Please report any issues to: https://github.com/NickJD/PyamilySeq/issues\n#####")
 
 if __name__ == "__main__":
+    #print("Running PyamilySeq "+PyamilySeq_Version)
     main()

PyamilySeq/PyamilySeq_Genus.py

@@ -1,10 +1,5 @@
 #from line_profiler_pycharm import profile
 
-import copy
-import sys
-import math
-from collections import Counter
-
 
 try:
     from .Constants import *
@@ -16,45 +11,6 @@ except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
     from utils import *
 
 
-
-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")
-
 def gene_presence_absence_output(options, genus_dict, pangenome_clusters_First_sorted, pangenome_clusters_First_sequences_sorted):
     print("Outputting gene_presence_absence file")
     output_dir = os.path.abspath(options.output_dir)
@@ -99,7 +55,7 @@ def gene_presence_absence_output(options, genus_dict, pangenome_clusters_First_s
 
 
 
-def get_cores(options,genus_dict):
+def get_cores(options):
     ##Calculate core groups
     groups = OrderedDict()
     cores = OrderedDict()
@@ -117,27 +73,26 @@ def get_cores(options,genus_dict):
             cores[only_second_core_group] = []
     return cores, groups
 
-
 #@profile
-def calc_First_only_core(cluster, First_number,  cores):
+def calc_First_only_core(cluster, First_num,  cores):
     try:
-        cores['First_genera_'+str(First_number)].append(cluster)
+        cores['First_genera_' + str(First_num)].append(cluster)
     except KeyError:
         cores['First_genera_>'].append(cluster)
 #@profile
 def calc_single_First_extended_Second_only_core(cluster, First_num, cores, Second_num): # Count gene families extended with StORFs
     group = First_num + Second_num
     try:
-        cores['extended_genera_' + group].append(cluster)
+        cores['extended_genera_' + str(group)].append(cluster)
     except KeyError:
         cores['extended_genera_>'].append(cluster)
 #@profile
 def calc_multi_First_extended_Second_only_core(cluster, First_num, cores, Second_num): # Count seperately those gene families extended with StORF_Reporter but combined >1 PEP
     group = First_num + Second_num
     try:
-        cores['combined_genera_' + group].append(cluster)
+        cores['combined_genera_' + str(group)].append(cluster)
     except KeyError:
-        cores['combined_genera_>' + group].append(cluster)
+        cores['combined_genera_>'].append(cluster)
 #@profile
 def calc_Second_only_core(cluster, cores, Second_num):
     try:
@@ -157,28 +112,26 @@ def calc_only_Second_only_core(cluster, cores, Second_num): # only count the tru
 def cluster(options):
 
     if options.cluster_format == 'CD-HIT':
-        genus_dict, pangenome_clusters_First, pangenome_clusters_First_sequences, reps = cluster_CDHIT(options, '_')
-    elif options.cluster_format in ['TSV','CSV']:
-        genus_dict, pangenome_clusters_First, pangenome_clusters_First_sequences, reps = cluster_EdgeList(options, '_')
-
+        genus_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps = cluster_CDHIT(options, '_')
+    elif 'TSV' in options.cluster_format or 'CSV' in options.cluster_format:
+        genus_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps = cluster_EdgeList(options, '_')
 
+    ###
+    cores, groups = get_cores(options)
+    ###
 
     if options.reclustered != None:
-
         if options.cluster_format == 'CD-HIT':
-            combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids,combined_pangenome_clusters_Second = combined_clustering_CDHIT(options, genus_dict, '_')
-        if options.cluster_format == ['TSV','CSV']:
-            combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids,combined_pangenome_clusters_Second = combined_clustering_Edge_List(options, '_')
-        pangenome_clusters_Type = combined_clustering_counting(options, pangenome_clusters_First, reps, combined_pangenome_clusters_First_Second_clustered, '_')
+            combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids,combined_pangenome_clusters_Second, combined_pangenome_clusters_Second_sequences = combined_clustering_CDHIT(options, genus_dict, '_')
+        elif 'TSV' in options.cluster_format or 'CSV' in options.cluster_format:
+            combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids,combined_pangenome_clusters_Second, combined_pangenome_clusters_Second_sequences = combined_clustering_Edge_List(options, '_')
+        pangenome_clusters_Type = combined_clustering_counting(options, pangenome_clusters_First, reps, combined_pangenome_clusters_First_Second_clustered, pangenome_clusters_First_genomes, '_')
     else:
-
         pangenome_clusters_Type = single_clustering_counting(pangenome_clusters_First, reps)
 
-    ###
-    cores, groups = get_cores(options, genus_dict)
-    ###
 
-    Number_Of_StORF_Extending_But_Same_Genomes = 0
+
+    Number_Of_Second_Extending_But_Same_Genomes = 0
 
     sorted_first_keys = sort_keys_by_values(pangenome_clusters_First, pangenome_clusters_First_sequences)
     pangenome_clusters_First_sorted = reorder_dict_by_keys(pangenome_clusters_First, sorted_first_keys)
@@ -186,19 +139,28 @@ def cluster(options):
     pangenome_clusters_Type_sorted = reorder_dict_by_keys(pangenome_clusters_Type, sorted_first_keys)
 
     print("Calculating Groups")
+    seen_groupings = []
     for cluster, numbers in pangenome_clusters_Type_sorted.items():
     ############################### Calculate First only
-        calc_First_only_core(cluster, numbers[1], cores)
+        cluster = str(cluster)
+        for grouping in numbers[2]: #!!# Could do with a more elegant solution
+            current_cluster = grouping[0].split(':')[0]
+            if current_cluster not in seen_groupings:
+                seen_groupings.append(current_cluster)
+                current_cluster_size = grouping[0].split(':')[1]
+                calc_First_only_core(current_cluster, current_cluster_size, cores)
+            ############################# Calculate First and Reclustered-Second
+                if numbers[0] == 1 and numbers[3] >= 1:  # If Seconds did not combine First reps
+                    calc_single_First_extended_Second_only_core(cluster, numbers[1], cores, numbers[3])
+                elif numbers[0] > 1 and numbers[3] >= 1:  # If unique Seconds combined multiple Firsts
+                    calc_multi_First_extended_Second_only_core(cluster, numbers[1], cores, numbers[3])
+                elif numbers[4] >= 1:
+                    Number_Of_Second_Extending_But_Same_Genomes += 1
+            else:
+                if options.verbose == True:
+                    print("First cluster " + current_cluster + " already processed - This is likely because it was clustered with another First representative.")
 
     if options.reclustered != None:
-        ############################# Calculate First and Reclustered-Second
-        if numbers[0] == 1 and numbers[3] >= 1:  # If Seconds did not combine First reps
-            calc_single_First_extended_Second_only_core(cluster, numbers[1], groups, cores, numbers[3])
-        elif numbers[0] > 1 and numbers[3] >= 1:  # If unique Secondss combined multiple Firsts
-            calc_multi_First_extended_Second_only_core(cluster, numbers[1], groups, cores, numbers[3])
-        elif numbers[4] >= 1:
-            Number_Of_StORF_Extending_But_Same_Genomes += 1
-
         combined_pangenome_clusters_ONLY_Second_Type = defaultdict(list)
         combined_pangenome_clusters_Second_Type = defaultdict(list)
         for cluster, genomes in combined_pangenome_clusters_Second.items():
@@ -207,52 +169,73 @@ def cluster(options):
             else:
                 combined_pangenome_clusters_ONLY_Second_Type[cluster] = [cluster, len(genomes)]
         for cluster, data in combined_pangenome_clusters_Second_Type.items():
-            if data[1] >=1:
+            if data[1] >= 1:
                 calc_Second_only_core(cluster, cores, data[1])
         for cluster, data in combined_pangenome_clusters_ONLY_Second_Type.items():
-            if data[1] >= 1 :
+            if data[1] >= 1:
                 calc_only_Second_only_core(cluster,  cores, data[1])
     ###########################
     ### Output
-    key_order = list(cores.keys())
     output_path = os.path.abspath(options.output_dir)
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
     stats_out = os.path.join(output_path,'summary_statistics.txt')
+    key_order = list(cores.keys())
     with open(stats_out,'w') as outfile:
         print("Genus Groups:")
         outfile.write("Genus Groups:\n")
         for key in key_order:
             print(key+':\t'+str(len(cores[key])))
             outfile.write(key + ':\t' + str(len(cores[key]))+'\n')
-        print("Total Number of Gene Groups (Including Singletons): " + str(len(pangenome_clusters_First_sequences_sorted)))
+        print("Total Number of First Gene Groups (Including Singletons): " + str(len(pangenome_clusters_First_sequences_sorted)))
         outfile.write("Total Number of Gene Groups (Including Singletons): " + str(len(pangenome_clusters_First_sequences_sorted)))
+        if options.reclustered!= None:
+            print("Total Number of Second Gene Groups (Including Singletons): " + str(
+                len(combined_pangenome_clusters_Second_sequences)))
+            print("Total Number of First Gene Groups That Had Additional Second Sequences But Not New Genomes: " + str(
+                Number_Of_Second_Extending_But_Same_Genomes))
+            outfile.write("\nTotal Number of Second Gene Groups (Including Singletons): " + str(
+                len(combined_pangenome_clusters_Second_sequences)))
+            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:
         gene_presence_absence_output(options,genus_dict, pangenome_clusters_First_sorted, pangenome_clusters_First_sequences_sorted)
 
-    if options.write_families != None and options.fasta != None:
-        sequences = read_fasta(options.fasta)
-        output_dir = os.path.join(output_path, 'Gene_Families_Output')
-
-        # 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_families.split(',') for part in key.split('_')):
-                    if key.startswith(key_prefix):
-                        for value in values:
-                            output_filename = f"{key}_{value}.fasta"
-                            sequences_to_write = pangenome_clusters_First_sequences_sorted[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")
-
-    if options.con_core != None and options.fasta != None and options.write_families != None:
-        process_gene_families(options, os.path.join(output_dir, 'Gene_Families_Output'), 'concatonated_genes_aligned.fasta')
+    if options.run_mode == 'Full':
+        if options.reclustered == None:
+            combined_pangenome_clusters_Second_sequences = None
+        if options.write_groups != 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)
+
+    elif options.run_mode == 'Partial':
+        if options.reclustered == None:
+            combined_pangenome_clusters_Second_sequences = None
+        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)
+
+
+    # if options.write_groups != None and options.fasta != None:
+    #     sequences = read_fasta(options.fasta)
+    #     output_dir = os.path.join(output_path, 'Gene_Families_Output')
+    #
+    #     write_groups(options,output_dir, key_order, cores, sequences,
+    #                  pangenome_clusters_First_sequences_sorted, combined_pangenome_clusters_Second_sequences)
+
+
+    #!!# - Currently only align in Species Mode
+    #if options.align_core != None and options.fasta != None and options.write_groups != None:
+    #    process_gene_families(options, os.path.join(output_path, 'Gene_Families_Output'), 'concatenated_genes_aligned.fasta')