PyamilySeq 0.9.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

PyamilySeq/PyamilySeq_Species.py

@@ -1,32 +1,27 @@
-#from line_profiler_pycharm import profile
-
-import math
 
 try:
-    from .Constants import *
+    from .constants import *
     from .clusterings import *
     from .utils import *
 except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
-    from Constants import *
+    from constants import *
     from clusterings import *
     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)
-    in_name = options.clusters.split('.')[0].split('/')[-1]
-    gpa_outfile = os.path.join(output_dir, in_name)
-    gpa_outfile = open(gpa_outfile+'_gene_presence_absence.csv','w')
+    #in_name = options.clusters.split('.')[0].split('/')[-1]
+    gpa_outfile = os.path.join(output_dir, 'gene_presence_absence.csv')
+    gpa_outfile = open(gpa_outfile, 'w')
     gpa_outfile.write('"Gene","Non-unique Gene name","Annotation","No. isolates","No. sequences","Avg sequences per isolate","Genome Fragment","Order within Fragment","'
                      '"Accessory Fragment","Accessory Order with Fragment","QC","Min group size nuc","Max group size nuc","Avg group size nuc","')
     gpa_outfile.write('","'.join(genome_dict.keys()))
     gpa_outfile.write('"\n')
     for cluster, sequences in pangenome_clusters_First_sequences_sorted.items():
         average_sequences_per_genome = len(sequences) / len(pangenome_clusters_First_sorted[cluster])
-        gpa_outfile.write('"group_'+str(cluster)+'","","'+str(len(pangenome_clusters_First_sorted[cluster]))+'","'+str(len(sequences))+'","'+str(average_sequences_per_genome)+
+        gpa_outfile.write('"group_'+str(cluster)+'","","",'+str(len(pangenome_clusters_First_sorted[cluster]))+'","'+str(len(sequences))+'","'+str(average_sequences_per_genome)+
                          '","","","","","","","","",""')
 
 
@@ -35,9 +30,9 @@ def gene_presence_absence_output(options, genome_dict, pangenome_clusters_First_
             tmp_list = []
             for value in sequences:
                 if value.split('|')[0] == genome:
-                    tmp_list.append(value)
+                    tmp_list.append(value.split('|')[1])
             if tmp_list:
-                full_out += ',"'+''.join(tmp_list)+'"'
+                full_out += ',"'+'\t'.join(tmp_list)+'"'
             else:
                 full_out = ',""'
             gpa_outfile.write(full_out)
@@ -64,7 +59,7 @@ def get_cores(options,genome_dict):
     cores = OrderedDict()
     prev_top = len(genome_dict)
     first = True
-    for group in options.core_groups.split(','):
+    for group in options.species_groups.split(','):
         calculated_floor = math.floor(int(group) / 100 * len(genome_dict))
         if first == False:
             groups[group] = (calculated_floor,prev_top)
@@ -138,14 +133,16 @@ def cluster(options):
 
     if options.cluster_format == 'CD-HIT':
         genome_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:
-        genome_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps = cluster_EdgeList(options, '|')
+    elif 'BLAST' in options.cluster_format:
+        genome_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps = cluster_BLAST(options, '|')
+    elif 'MMseqs' in options.cluster_format:
+        genome_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps = cluster_MMseqs(options, '|')
 
     ###
     cores, groups = get_cores(options, genome_dict)
     ###
 
-    if options.reclustered != None:
+    if options.reclustered != None: #FIX
         if options.cluster_format == 'CD-HIT':
             combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids,combined_pangenome_clusters_Second, combined_pangenome_clusters_Second_sequences = combined_clustering_CDHIT(options, genome_dict, '|')
         elif 'TSV' in options.cluster_format or 'CSV' in options.cluster_format:
@@ -169,8 +166,6 @@ def cluster(options):
     for cluster, numbers in pangenome_clusters_Type_sorted.items():
     ############################### Calculate First only
         cluster = str(cluster)
-        if '78' in cluster:
-            pass
         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:
@@ -210,8 +205,10 @@ def cluster(options):
     stats_out = os.path.join(output_path,'summary_statistics.txt')
     key_order = ['First_core_', 'extended_core_', 'combined_core_', 'Second_core_','only_Second_core_']
     with open(stats_out, 'w') as outfile:
+        print("Number of Genomes: " + str(len(genome_dict)))
+        outfile.write("Number of Genomes: " + str(len(genome_dict)) + "\n")
         print("Gene Groups:")
-        outfile.write("Gene Groups:\n")
+        outfile.write("Gene Groups\n")
         for key_prefix in key_order:
             for key, value in cores.items():
                 if key.startswith(key_prefix):
@@ -236,34 +233,59 @@ def cluster(options):
     ###Need to fix this below. If full/partial the ifs need to be different. If full we first need to output the gfs then align. if -wruite-groups not presented then it needs
     # to be done for alignment full anyway...
 
+    genome_list = list(genome_dict.keys())
     if options.run_mode == 'Full':
+        sequences = read_fasta(options.fasta)
         if options.reclustered == None:
             combined_pangenome_clusters_Second_sequences = None
+        ## Output representative sequences
+        representatives_out = os.path.join(output_path,'pan_genome_reference.fa')
+        with open(representatives_out, 'w') as outfile:
+            for cluster, ids in pangenome_clusters_First_sequences.items():
+                outfile.write('>group_'+str(cluster)+'\n')
+                wrapped_aa_seq = wrap_sequence(sequences[ids[0]], 60)
+                outfile.write(wrapped_aa_seq+'\n')
         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,
+            output_dir = os.path.join(options.output_dir, 'Gene_Groups_Output')
+            write_groups_func(options,output_dir, key_order, cores, sequences,
                          pangenome_clusters_First_sequences_sorted, combined_pangenome_clusters_Second_sequences)
 
             if options.align_core != None:
                 print("Processing gene group alignment")
-                process_gene_families(options, output_dir, 'concatenated_genes_aligned.fasta')
+                process_gene_groups(options, output_dir, None, None, genome_list, 'core_gene_alignment.aln')
 
     elif options.run_mode == 'Partial':
+        sequences = read_fasta(options.fasta)
         if options.reclustered == None:
             combined_pangenome_clusters_Second_sequences = None
-        if options.write_groups != None and options.fasta != None:
+        # else: ## Output representative sequences - Under development
+        #     representatives_out = os.path.join(output_path, 'pan_genome_reference_reclustered.fa')
+        #     with open(representatives_out, 'w') as outfile:
+        #         for cluster, ids in combined_pangenome_clusters_Second_sequences.items():
+        #             outfile.write('>group_' + str(cluster) + '\n')
+        #             try:
+        #                 wrapped_aa_seq = wrap_sequence(sequences[ids[0]], 60)
+        #             except:
+        #                 print(2)
+        #             outfile.write(wrapped_aa_seq + '\n')
+        ## Output representative sequences
+        representatives_out = os.path.join(output_path,'pan_genome_reference.fa')
+        with open(representatives_out, 'w') as outfile:
+            for cluster, ids in pangenome_clusters_First_sequences.items():
+                outfile.write('>group_'+str(cluster)+'\n')
+                wrapped_aa_seq = wrap_sequence(sequences[ids[0]], 60)
+                outfile.write(wrapped_aa_seq+'\n')
+        if options.write_groups != None:
             print("Outputting gene group FASTA files")
-            sequences = read_fasta(options.fasta)
-            output_dir = os.path.join(options.output_dir, 'Gene_Families_Output')
-            write_groups(options,output_dir, key_order, cores, sequences,
+            output_dir = os.path.join(options.output_dir, 'Gene_Groups_Output')
+            write_groups_func(options,output_dir, key_order, cores, sequences,
                          pangenome_clusters_First_sequences_sorted, combined_pangenome_clusters_Second_sequences)
 
             if options.align_core != None:
                 print("Processing gene group alignment")
-                process_gene_families(options, output_dir, 'concatenated_genes_aligned.fasta')
+                process_gene_groups(options, output_dir, None, None, genome_list, 'core_gene_alignment.aln')
 
 
 

PyamilySeq/Seq_Combiner.py

@@ -2,10 +2,10 @@ import argparse
 
 
 try:
-    from .Constants import *
+    from .constants import *
     from .utils import *
 except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
-    from Constants import *
+    from constants import *
     from utils import *
 
 
@@ -29,7 +29,7 @@ def main():
                           help="Directory for all output files.",
                           required=True)
     required.add_argument("-output_name", action="store", dest="output_file",
-                          help="Output file name.",
+                          help="Output file name (without .fasta).",
                           required=True)
 
     optional = parser.add_argument_group('Optional Arguments')
@@ -38,7 +38,7 @@ def main():
                                ' - Not compatible with "fasta" input mode.',
                           required=False)
     optional.add_argument('-translate', action='store_true', dest='translate', default=None,
-                          help='Default - False: Translate extracted sequences to their AA counterpart?',
+                          help='Default - False: Translate extracted sequences to their AA counterpart? - appends _aa.fasta to given output_name',
                           required=False)
     misc = parser.add_argument_group('Misc Arguments')
     misc.add_argument("-v", "--version", action="version",
@@ -47,14 +47,13 @@ def main():
 
     options = parser.parse_args()
 
-    if options.version:
-        sys.exit(PyamilySeq_Version)
+
 
     output_path = os.path.abspath(options.output_dir)
     if not os.path.exists(output_path):
         os.makedirs(output_path)
 
-    combined_out_file = os.path.join(output_path, options.output_file)
+    combined_out_file = os.path.join(output_path, options.output_file + '.fasta')
 
     if options.input_type == 'separate':
         read_separate_files(options.input_dir, options.name_split, options.gene_ident, combined_out_file, options.translate)

PyamilySeq/Seq_Extractor.py

@@ -0,0 +1,64 @@
+import argparse
+import copy
+
+def find_gene_ids_in_csv(csv_file, group_name):
+    """Find gene IDs associated with the specified group name in the CSV file, starting from column 14."""
+    gene_ids = []
+    with open(csv_file, 'r') as f:
+        for line in f:
+            cells = line.strip().split(',')
+            if cells[0].replace('"','') == group_name:
+                # Collect gene IDs from column 14 onward
+                for cell in cells[14:]:
+                    gene_ids.extend(cell.strip().replace('"','').split())  # Splitting by spaces if there are multiple IDs in a cell                break
+    return gene_ids
+
+def extract_sequences(fasta_file, gene_ids):
+    """Extract sequences from the FASTA file that match the gene IDs."""
+    sequences = {}
+    capture = False
+    current_id = ""
+    not_found = copy.deepcopy(gene_ids)
+    with open(fasta_file, 'r') as f:
+        for line in f:
+            if line.startswith('>'):
+                # Extract the ID part after '>' and check if it's in gene_ids
+                current_id = line[1:].strip().split()[0].split('|')[1]
+                capture = current_id in gene_ids
+                if current_id in not_found:
+                    not_found.remove(current_id)
+                if capture:
+                    sequences[current_id] = [line.strip()]  # Start with header line
+            elif capture:
+                sequences[current_id].append(line.strip())  # Append sequence lines
+    return sequences
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract sequences for specified group name from CSV file and corresponding FASTA file.")
+    parser.add_argument("-csv", action='store', dest='csv_file',
+                        help="CSV file containing group data", required=True)
+    parser.add_argument("-group", action='store', dest='group_name',
+                        help="Group name to search for in the CSV", required=True)
+    parser.add_argument("-fasta", action='store', dest='fasta_file',
+                        help="Input FASTA file containing sequences", required=True)
+    parser.add_argument("-out", action='store', dest='output_file',
+                        help="Output FASTA file with extracted sequences", required=True)
+
+    options = parser.parse_args()
+
+    # Find gene IDs in CSV
+    gene_ids = find_gene_ids_in_csv(options.csv_file, options.group_name)
+    if not gene_ids:
+        print(f"No gene IDs found for group name '{options.group_name}' in the CSV.")
+        return
+
+    # Extract sequences from the FASTA file
+    sequences = extract_sequences(options.fasta_file, gene_ids)
+
+    # Write matched sequences to the output FASTA file
+    with open(options.output_file, 'w') as output:
+        for gene_id, sequence_lines in sequences.items():
+            output.write("\n".join(sequence_lines) + "\n")
+
+if __name__ == "__main__":
+    main()

PyamilySeq/Seq_Finder.py

@@ -0,0 +1,56 @@
+import argparse
+import collections
+import csv
+
+
+def parse_fasta_ids(fasta_file):
+    """Extract IDs from the FASTA file."""
+    ids = []
+    with open(fasta_file, 'r') as f:
+        for line in f:
+            if line.startswith('>'):
+                seq_id = line[1:].strip().split()[0]  # Capture the ID after '>'
+                ids.append(seq_id)
+    return ids
+
+
+def find_ids_in_csv(ids, csv_file):
+    """Search for each ID in the CSV file and report the first column where it is found."""
+    found_records = collections.defaultdict(list)
+    with open(csv_file, 'r') as f:
+        csv_reader = csv.reader(f)
+        for row in csv_reader:
+            if row:  # Ensure row is not empty
+
+                for id in ids: # slow
+                    if id in row:
+                        found_records[row[0]].append(id)
+    return found_records
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract IDs from a FASTA file and search for them in a CSV file.")
+    parser.add_argument("-in", action='store', dest='fasta_file',
+                        help="Input FASTA file", required=True)
+    parser.add_argument("-ids", action='store', dest='csv_file',
+                        help="CSV file containing IDs to search for", required=True)
+    parser.add_argument("-out", action='store', dest='output_file',
+                        help="Output file to save found IDs", required=True)
+
+    options = parser.parse_args()
+
+    # Parse IDs from the FASTA file
+    ids = parse_fasta_ids(options.fasta_file)
+
+    # Find IDs in the CSV file
+    found_records = find_ids_in_csv(ids, options.csv_file)
+
+    # Write output
+    with open(options.output_file, 'w') as output:
+        output.write("ID,Found_In_First_Column\n")
+        for seq_id, found_in in found_records.items():
+            output.write(f"{seq_id},{found_in}\n")
+
+
+if __name__ == "__main__":
+    main()

PyamilySeq/clusterings.py

@@ -52,6 +52,107 @@ def cluster_CDHIT(options, splitter):
 
     return taxa_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps
 
+def cluster_BLAST(options, splitter):
+    separator = '\t'
+    First_in = open(options.clusters, 'r')
+    pangenome_clusters_First = OrderedDict()
+    pangenome_clusters_First_genomes = defaultdict(list)
+    pangenome_clusters_First_sequences = defaultdict(list)
+    taxa_dict = defaultdict(int)
+    reps = OrderedDict()
+    edges = defaultdict(list)
+    for line in First_in:
+        elements = line.strip().split(separator)
+        rep, child = elements[0], elements[1]
+        child_taxa = child.split(splitter)[0]  # Extracting the genome identifier from the child sequence
+        # Counting occurrences of genomes
+        taxa_dict[child_taxa] += 1
+        edges[rep].append(child)
+        edges[child].append(rep)
+
+    visited = set()
+    cluster_id = 0
+
+    def dfs(node, cluster_id):
+        stack = [node]
+        tmp_genomes = []
+        while stack:
+            current = stack.pop()
+            if current not in visited:
+                visited.add(current)
+                clustered_taxa = current.split(splitter)[0]
+                pangenome_clusters_First_sequences[cluster_id].append(current)
+                if clustered_taxa not in pangenome_clusters_First[cluster_id]:
+                    pangenome_clusters_First[cluster_id].append(clustered_taxa)
+                    tmp_genomes.append(clustered_taxa)
+                for neighbor in edges[current]:
+                    if neighbor not in visited:
+                        stack.append(neighbor)
+
+        pangenome_clusters_First_genomes[node] = tmp_genomes
+
+    for node in edges:
+        if node not in visited:
+            pangenome_clusters_First[cluster_id] = []
+            pangenome_clusters_First_sequences[cluster_id] = []
+            pangenome_clusters_First_genomes[node] = []
+            dfs(node, cluster_id)
+            cluster_id += 1
+
+    for rep in pangenome_clusters_First:
+        cluster_size = len(pangenome_clusters_First_sequences[rep])
+        reps[rep] = [cluster_size, len(pangenome_clusters_First[rep])]
+
+    return taxa_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps
+
+def cluster_MMseqs(options,splitter):
+    separator = '\t'
+    cluster_id = 0
+    last_rep = ''
+    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:
+
+        elements = line.strip().split(separator)
+        rep, child = elements[0], elements[1]
+        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'] = []
+            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[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[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_genomes, pangenome_clusters_First_sequences, reps
 
 
 #@profile
@@ -138,10 +239,10 @@ def single_clustering_counting(pangenome_clusters_First, reps):
     pangenome_clusters_Type = copy.deepcopy(pangenome_clusters_First)
     list_of_reps = list(reps.keys())
     for cluster, First_taxa in pangenome_clusters_First.items():
-        rep = list_of_reps[int(cluster)]  # get the rep of the current pep cluster
+        rep = list_of_reps[int(cluster)]  # get the rep of the current cluster
 
         try:  # get the cluster from the storf clusters which contains this rep
-            num_clustered_First[str(cluster)].append(rep + '_' + str(len(First_taxa)))
+            num_clustered_First[str(cluster)].append(str(rep) + '_' + str(len(First_taxa)))
             size_of_First_clusters = []
             Firsts = num_clustered_First[str(cluster)]
             for First in Firsts:
@@ -178,6 +279,8 @@ def combined_clustering_CDHIT(options, taxa_dict, splitter):
     first = True
     for line in Second_in:
         if line.startswith('>'):
+            if '>Cluster 1997' in line:
+                print()
             if first == False:
                 cluster_size = len(Combined_clusters[cluster_id])
                 Combined_reps.update({rep: cluster_size})
@@ -196,6 +299,7 @@ def combined_clustering_CDHIT(options, taxa_dict, splitter):
                         VALUE = combined_pangenome_clusters_Second_sequences[cluster_id]
                     KEY = combined_pangenome_clusters_First_sequences[cluster_id][0]
                     combined_pangenome_clusters_First_Second_clustered.update({KEY: VALUE})
+
             cluster_id = line.strip('>')
             cluster_id = cluster_id.strip('\n')
             cluster_id = cluster_id.split(' ')[1]
@@ -233,55 +337,40 @@ def combined_clustering_CDHIT(options, taxa_dict, splitter):
     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):
-    if options.cluster_format == 'TSV':
-        separator = '\t'
-    elif options.cluster_format == 'CSV':
-        separator = ','
-    cluster_id = 0
-    last_rep = ''
-    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'] = []
-            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[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)
+# def cluster_BLAST(options, splitter):
+#     separator = '\t'
+#     First_in = open(options.clusters, 'r')
+#     pangenome_clusters_First = OrderedDict()
+#     pangenome_clusters_First_genomes = defaultdict(list)
+#     pangenome_clusters_First_sequences = defaultdict(list)
+#     taxa_dict = defaultdict(int)
+#     reps = OrderedDict()
+#
+#     for line in First_in:
+#         elements = line.strip().split(separator)
+#         rep, child = elements[0], elements[1]
+#         child_taxa = child.split(splitter)[0]  # Extracting the genome identifier from the child sequence
+#         # Counting occurrences of genomes
+#         taxa_dict[child_taxa] += 1
+#
+#         if rep not in pangenome_clusters_First:
+#             pangenome_clusters_First[rep] = []
+#             pangenome_clusters_First_sequences[rep] = []
+#
+#         if child_taxa not in pangenome_clusters_First[rep]:
+#             pangenome_clusters_First[rep].append(child_taxa)
+#             pangenome_clusters_First_genomes[rep].append(child_taxa)
+#
+#         pangenome_clusters_First_sequences[rep].append(child)
+#
+#     for rep in pangenome_clusters_First:
+#         cluster_size = len(pangenome_clusters_First_sequences[rep])
+#         reps[rep] = [cluster_size, len(pangenome_clusters_First[rep])]
+#
+#     return taxa_dict, pangenome_clusters_First, pangenome_clusters_First_genomes, pangenome_clusters_First_sequences, reps
 
-        pangenome_clusters_First_sequences[str(cluster_id)].append(child)
-        last_rep = rep
-        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_genomes, pangenome_clusters_First_sequences, reps
 
 
 def combined_clustering_Edge_List(options, splitter):
@@ -305,7 +394,8 @@ def combined_clustering_Edge_List(options, splitter):
     Combined_reps = OrderedDict()
     first = True
     for line in Second_in:
-        rep, child = line.strip().split(separator)
+        elements = line.strip().split(separator)
+        rep, child = elements[0], elements[1]
         child_taxa = child.split(splitter)[0]  # Extracting the genome identifier from the child sequence
 
         if first == True:

PyamilySeq/constants.py

@@ -0,0 +1,2 @@
+PyamilySeq_Version = 'v1.0.1'
+