PyamilySeq 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

PyamilySeq/Constants.py

@@ -1 +1,15 @@
-PyamilySeq_Version = 'v0.2.0'
+import subprocess
+
+PyamilySeq_Version = 'v0.4.0'
+
+
+
+def is_tool_installed(tool_name):
+    """Check if a tool is installed and available in PATH."""
+    try:
+        subprocess.run([tool_name, '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+    except FileNotFoundError:
+        return False

PyamilySeq/PyamilySeq.py

@@ -0,0 +1,186 @@
+import argparse
+import collections
+import os
+import glob
+import subprocess
+from PyamilySeq_Species import *
+
+
+try:
+    from .PyamilySeq_Species import cluster
+    from .Constants import *
+except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
+    from PyamilySeq_Species import cluster
+    from Constants import *
+
+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 read_separate_files(input_dir, name_split, combined_out):
+    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]
+            corresponding_gff_file = fasta_file.replace('.fasta', '.gff')
+            if not os.path.exists(corresponding_gff_file):
+                continue
+            cds_sequences = extract_cds_from_gff(fasta_file, corresponding_gff_file)
+            for gene_name, seq in cds_sequences:
+                header = f">{genome_name}_{gene_name}\n"
+                combined_out_file.write(header)
+                combined_out_file.write(seq + '\n')
+
+def read_combined_files(input_dir, name_split, combined_out):
+    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]
+            fasta_dict = collections.defaultdict(str)
+            gff_features = []
+            with open(gff_file, 'r') as file:
+                lines = file.readlines()
+                fasta_section = False
+                for line in lines:
+                    if line.startswith('##FASTA'):
+                        fasta_section = True
+                        continue
+                    if fasta_section:
+                        if line.startswith('>'):
+                            current_contig = line[1:].split()[0]
+                            fasta_dict[current_contig] = []
+                        else:
+                            fasta_dict[current_contig].append(line.strip())
+                    else:
+                        line_data = line.split('\t')
+                        if len(line_data) == 9:
+                            if line_data[2] == 'CDS':
+                                contig = line_data[0]
+                                feature = line_data[2]
+                                start, end = int(line_data[3]), int(line_data[4])
+                                seq_id = line_data[8].split('ID=')[1].split(';')[0]
+                                gff_features.append((contig, start, end, seq_id))
+
+                if fasta_dict and gff_features:
+                    for contig, start, end, seq_id in gff_features:
+                        if contig in fasta_dict:
+                            full_sequence = ''.join(fasta_dict[contig])
+                            cds_sequence = full_sequence[start - 1:end]
+                            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 run_cd_hit(input_file, clustering_output, options):
+    cdhit_command = [
+        'cd-hit-est',
+        '-i', input_file,
+        '-o', clustering_output,
+        '-c', str(options.pident),
+        '-s', str(options.len_diff),
+        '-T', "20",
+        '-d', "0",
+        '-sc', "1",
+        '-sf', "1"
+    ]
+    subprocess.run(cdhit_command)
+
+
+
+
+
+
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='PyamilySeq ' + PyamilySeq_Version + ': PyamilySeq Run Parameters.')
+    required = parser.add_argument_group('Required Arguments')
+    required.add_argument("-id", action="store", dest="input_dir",
+                          help="Directory containing GFF/FASTA files.",
+                          required=True)
+    required.add_argument("-od", action="store", dest="output_dir",
+                          help="Directory for all output files.",
+                          required=True)
+    required.add_argument("-it", action="store", dest="input_type", choices=['separate', 'combined'],
+                        help="Type of input files: 'separate' for separate FASTA and GFF files,"
+                             " 'combined' for GFF files with embedded FASTA sequences.",
+                          required=True)
+    required.add_argument("-ns", action="store", dest="name_split",
+                          help="Character used to split the filename and extract the genome name.",
+                          required=True)
+    required.add_argument("-pid", action="store", dest="pident", type=float,
+                          help="Pident threshold for CD-HIT clustering.",
+                          required=True)
+    required.add_argument("-ld", action="store", dest="len_diff", type=float,
+                          help="Length difference (-s) threshold for CD-HIT clustering.",
+                          required=True)
+    required.add_argument("-co", action="store", dest="clustering_out",
+                          help="Output file for initial clustering.",
+                          required=True)
+    required.add_argument("-ct", action="store", dest="clustering_type", choices=['CD-HIT', 'BLAST', 'DIAMOND', "MMseqs2"],
+                        help="Clustering format for PyamilySeq.",
+                          required=True)
+
+    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',
+                          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',
+                          required=False)
+    output_args.add_argument('-fasta', action='store', dest='fasta',
+                          help='FASTA file to use in conjunction with "-w" or "-con"',
+                          required=False)
+
+    optional = parser.add_argument_group('Optional Arguments')
+    optional.add_argument('-rc', action='store', dest='reclustered', help='Clustering output file from secondary round of clustering',
+                        required=False)
+    optional.add_argument('-st', action='store', dest='sequence_tag', help='Default - "StORF": Unique identifier to be used to distinguish the second of two rounds of clustered sequences',
+                        required=False)
+    optional.add_argument('-groups', action="store", dest='core_groups', default="99,95,15",
+                        help='Default - (\'99,95,15\'): Gene family groups to use')
+    optional.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)
+
+    parser.add_argument("pyamilyseq_args", nargs=argparse.REMAINDER, help="Additional arguments for PyamilySeq.")
+    options = parser.parse_args()
+
+
+
+    output_path = os.path.abspath(options.output_dir)
+    combined_out_file = os.path.join(output_path,"end_to_end_combined_sequences.fasta")
+    clustering_output = os.path.join(output_path,'clustering_'+options.clustering_type)
+
+
+
+    # Step 1: Read and rename sequences from files based on input type
+    if options.input_type == 'separate':
+        read_separate_files(options.input_dir, options.name_split, combined_out_file)
+    else:
+        read_combined_files(options.input_dir, options.name_split, combined_out_file)
+
+    # Step 2: Run CD-HIT on the renamed sequences
+    run_cd_hit(combined_out_file, clustering_output, options)
+
+
+    class clustering_options:
+        def __init__(self):
+            self.format = 'CD-HIT'
+            self.reclustered = options.reclustered
+            self.sequence_tag = 'StORF'
+            self.core_groups = '99,95,15,0'
+            self.clusters = clustering_output+'.clstr'
+            self.gene_presence_absence_out = options.gene_presence_absence_out
+            self.write_families = options.write_families
+            self.con_core = options.con_core
+
+    clustering_options = clustering_options()
+
+    # Step 3: Run PyamilySeq with the CD-HIT output
+    cluster(clustering_options)
+    #run_pyamilyseq(options.clustering_out, options.clustering_type, combined_out_file, options.pyamilyseq_args)
+
+
+if __name__ == "__main__":
+    main()

PyamilySeq/PyamilySeq_Species.py

@@ -6,6 +6,9 @@ import math
 import sys
 import argparse
 import os
+from tempfile import NamedTemporaryFile
+
+
 
 try:
     from .Constants import *
@@ -20,6 +23,75 @@ def sort_keys_by_values(dict1, dict2):
     sorted_keys = sorted(dict1.keys(), key=lambda k: custom_sort_key(k, dict1, dict2), reverse=True)
     return sorted_keys
 
+def select_longest_gene(sequences):
+    """Select the longest sequence for each genome."""
+    longest_sequences = {}
+    for seq_id, sequence in sequences.items():
+        genome = seq_id.split('|')[0]  # Assuming genome name can be derived from the sequence ID
+        if genome not in longest_sequences or len(sequence) > len(longest_sequences[genome][1]):
+            longest_sequences[genome] = (seq_id, sequence)
+    return longest_sequences
+
+
+def run_mafft_on_sequences(sequences, output_file):
+    """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:
+        for header, sequence in sequences.items():
+            temp_input_file.write(f">{header}\n{sequence}\n")
+        temp_input_file_path = temp_input_file.name
+
+    # Run mafft
+    try:
+        with open(output_file, 'w') as output_f:
+            subprocess.run(
+                ['mafft', '--auto', temp_input_file_path],
+                stdout=output_f,
+                stderr=subprocess.DEVNULL,  # Suppress stderr
+                check=True
+            )
+    finally:
+        os.remove(temp_input_file_path)  # Clean up the temporary file
+
+
+def process_gene_families(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({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, genome_dict, pangenome_clusters_First_sorted, pangenome_clusters_First_sequences_sorted):
     print("Outputting gene_presence_absence file")
     in_name = options.clusters.split('.')[0]
@@ -92,7 +164,11 @@ def get_cores(options,genome_dict):
     for group in options.core_groups.split(','):
         calculated_floor = math.floor(int(group) / 100 * len(genome_dict))
         if first == False:
-            groups[group] = (calculated_floor,prev_top -1)
+            # Ensure no overlap
+            # if calculated_floor <= prev_top:
+            #     calculated_floor = prev_top - 1
+
+            groups[group] = (calculated_floor,prev_top)
         else:
             groups[group] = (calculated_floor, prev_top)
             first = False
@@ -209,28 +285,28 @@ def combined_clustering_counting(options, pangenome_clusters_First, reps, combin
 
 #@profile
 def single_clustering_counting(options, pangenome_clusters_First, reps):
-    num_clustered_PEP = defaultdict(list)
-    recorded_PEP = []
+    num_clustered_First = defaultdict(list)
+    recorded_First = []
     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
 
         try:  # get the cluster from the storf clusters which contains this rep
-            num_clustered_PEP[cluster].append(rep + '_' + str(len(pep_genomes)))
-            size_of_pep_clusters = []
-            peps = num_clustered_PEP[cluster]
-            for pep in peps:
-                pep = pep.rsplit('_', 1)
-                size_of_pep_clusters.append(int(pep[1]))
-                recorded_PEP.append(pep[0])
-            pangenome_clusters_Type[cluster] = [len(num_clustered_PEP[cluster]), sum(size_of_pep_clusters),
-                                                size_of_pep_clusters, 0, 0, 0]
+            num_clustered_First[cluster].append(rep + '_' + str(len(First_genomes)))
+            size_of_First_clusters = []
+            Firsts = num_clustered_First[cluster]
+            for First in Firsts:
+                First = First.rsplit('_', 1)
+                size_of_First_clusters.append(int(First[1]))
+                recorded_First.append(First[0])
+            pangenome_clusters_Type[cluster] = [len(num_clustered_First[cluster]), sum(size_of_First_clusters),
+                                                size_of_First_clusters, 0, 0, 0]
 
         except KeyError:
             ###Singleton
-            num_pep_genomes = [len(pep_genomes)]
-            pangenome_clusters_Type[cluster] = [1, len(pep_genomes), num_pep_genomes, 0, 0, 0]
+            num_pep_genomes = [len(First_genomes)]
+            pangenome_clusters_Type[cluster] = [1, len(First_genomes), num_pep_genomes, 0, 0, 0]
 
     return pangenome_clusters_Type
 
@@ -493,7 +569,7 @@ def cluster(options):
         pangenome_clusters_Type = single_clustering_counting(options, pangenome_clusters_First, reps)
 
 
-    counter = 0
+
     Number_Of_StORF_Extending_But_Same_Genomes = 0
 
     sorted_first_keys = sort_keys_by_values(pangenome_clusters_First, pangenome_clusters_First_sequences)
@@ -504,12 +580,12 @@ def cluster(options):
     print("Calculating Groups")
     for cluster, numbers in pangenome_clusters_Type_sorted.items():
     ############################### Calculate First only
-        if numbers[0] == 1 and numbers[1] >=2:
-            calc_First_only_core(cluster, numbers[1],groups,cores)
-            counter +=1
-        elif numbers[0] >1 and numbers[1] >=2:
-            calc_First_only_core(cluster, numbers[2][0],groups,cores)
-            counter += 1
+        #if numbers[0] == 1 and numbers[1] >=2:
+        calc_First_only_core(cluster, numbers[1],groups,cores)
+
+        # elif numbers[0] >1 and numbers[1] >=2:
+        #     calc_First_only_core(cluster, numbers[2][0],groups,cores)
+
 
     if options.reclustered != None:
         ############################# Calculate First and Reclustered-Second
@@ -532,13 +608,13 @@ def cluster(options):
             if data[1] >= 2:
                 calc_only_Second_only_core(groups, cores, data[1])
     ###########################
-    print("End")
     key_order = ['first_core_', 'extended_core_', 'combined_core_', 'second_core_','only_second_core_']
-    print("Gene Family Groups:")
+    print("Gene Groups:")
     for key_prefix in key_order:
         for key, value in cores.items():
             if key.startswith(key_prefix):
                 print(f"{key}: {len(value)}")
+    print("Total Number of Gene Groups (Including Singletons): " + str(len(pangenome_clusters_First_sequences_sorted)))
 
     if options.gene_presence_absence_out != None:
         gene_presence_absence_output(options,genome_dict, pangenome_clusters_First_sorted, pangenome_clusters_First_sequences_sorted)
@@ -566,25 +642,107 @@ def cluster(options):
                                         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(os.path.join(input_dir, 'Gene_Families_Output'), 'concatonated_genes_aligned.fasta')
+
+
+        # groups_dir = os.path.join(input_dir, 'Gene_Families_Output')
+        # """Run mafft on all .fasta files in the given directory."""
+        # for filename in os.listdir(groups_dir):
+        #     if filename.endswith('.fasta'):
+        #         input_path = os.path.join(groups_dir, filename)
+        #         output_filename = filename.replace('.fasta', '_mafft.aln')
+        #         output_path = os.path.join(groups_dir, output_filename)
+        #
+        #         # Call mafft command
+        #         try:
+        #             with open(output_path, 'w') as output_file:
+        #                 subprocess.run(
+        #                     ['mafft', '--auto', input_path],
+        #                     stdout=output_file,
+        #                     stderr=subprocess.DEVNULL,  # Suppress stderr
+        #                     check=True
+        #                 )
+        #             print(f"Processed {input_path} -> {output_path}")
+        #         except subprocess.CalledProcessError as e:
+        #             print(f"Failed to process {input_path}: {e}")
+
+        ##This could be run once and not above AND here..
+        # output_dir = os.path.dirname(os.path.abspath(options.clusters))
+        # sequences = read_fasta(options.fasta)
+        # concatenated_sequences = {genome: '' for genome in genome_dict.keys()}
+        #
+        #
+        # for key_prefix in key_order:
+        #     for key, values in cores.items():
+        #         if any(part in options.con_core.split(',') for part in key.split('_')):
+        #             if key.startswith(key_prefix):
+        #                 for value in values:
+        #                     length_capture = {genome: [] for genome in genome_dict.keys()}
+        #                     sequences_to_write = pangenome_clusters_First_sequences_sorted[value]
+        #                     for header in sequences_to_write:
+        #                         if header in sequences:
+        #                             length_capture[header.split('|')[0]].append([header,len(sequences[header])])
+        #                     if all(bool(values) for values in length_capture.values()): # If a GF is not present in 'ALL' genomes, do not add to concat
+        #                         for genome, lengths in length_capture.items():
+        #                             max_value = float('-inf')
+        #                             max_item = None
+        #                             for length in lengths:
+        #                                 current_value = length[1]
+        #                                 if current_value > max_value:
+        #                                     max_value = current_value
+        #                                     max_item = length[0]
+        #                             concatenated_sequences[genome.split('|')[0]] += sequences[max_item]
+        #
+        #
+        # with open(os.path.join(output_dir, 'core_concat.fasta'), 'w') as outfile:
+        #     for genome, sequence in concatenated_sequences.items():
+        #         outfile.write(f">{genome}\n")
+        #         wrapped_sequence = wrap_sequence(sequence)
+        #         outfile.write(f"{wrapped_sequence}\n")
+
+
+        # for core_gene_family in core_gene_families:
+        #     found_sequences = {genome: False for genome in genomes}
+        #
+        #     for fasta_file in fasta_files:
+        #         sequences = read_fasta(fasta_file)
+        #         for header, sequence in sequences.items():
+        #             genome = header.split('|')[0]
+        #             if genome in genomes and core_gene_family in header:
+        #                 concatenated_sequences[genome] += sequence
+        #                 found_sequences[genome] = True
+        #
+        #     for genome in genomes:
+        #         if not found_sequences[genome]:
+        #             concatenated_sequences[genome] += '-' * len(next(iter(sequences.values())))
+
+
 
 
 def main():
 
-    parser = argparse.ArgumentParser(description='PyamilySeq ' + PyamilySeq_Version + ': PyamilySeq Run Parameters.')
+    parser = argparse.ArgumentParser(description='PyamilySeq-Species ' + PyamilySeq_Version + ': PyamilySeq-Species Run Parameters.')
     parser._action_groups.pop()
 
     required = parser.add_argument_group('Required Arguments')
     required.add_argument('-c', action='store', dest='clusters', help='Clustering output file from CD-HIT, TSV or CSV Edge List',
                         required=True)
     required.add_argument('-f', action='store', dest='format', choices=['CD-HIT', 'CSV', 'TSV'],
-                        help='Which format to use (CD-HIT or  Comma/Tab Separated Edge-List (such as MMseqs2 tsv output))', required=True)
+                        help='Which format to use (CD-HIT or  Comma/Tab Separated Edge-List (such as MMseqs2 tsv output))',
+                        required=True)
 
     output_args = parser.add_argument_group('Output Parameters')
-    output_args.add_argument('-w', action="store", dest='write_families', default="99",
-                          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_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',
+                          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',
+                          required=False)
     output_args.add_argument('-fasta', action='store', dest='fasta',
-                          help='FASTA file to use in conjunction with "-w"',
+                          help='FASTA file to use in conjunction with "-w" or "-con"',
                           required=False)
 
     optional = parser.add_argument_group('Optional Arguments')
@@ -592,16 +750,18 @@ def main():
                         required=False)
     optional.add_argument('-st', action='store', dest='sequence_tag', help='Default - "StORF": Unique identifier to be used to distinguish the second of two rounds of clustered sequences',
                         required=False)
-    optional.add_argument('-groups', action="store", dest='core_groups', default="99,95,90,80,15",
-                        help='Default - (\'99,95,90,80,15\'): Gene family groups to use')
+    optional.add_argument('-groups', action="store", dest='core_groups', default="99,95,15",
+                        help='Default - (\'99,95,15\'): Gene family groups to use')
     optional.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)
 
     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')
+                        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')
+                        help='Default - False: Print out version number and exit',
+                        required=False)
 
 
     options = parser.parse_args()
@@ -614,6 +774,11 @@ def main():
     if options.sequence_tag == None:
         options.sequence_tag = 'StORF'
 
+    if options.con_core == True:
+        if is_tool_installed('mafft'):
+            print("mafft is installed. Proceeding with alignment.")
+        else:
+            print("mafft is not installed. Please install mafft to proceed.")
 
     if options.write_families != None and options.fasta == False:
         exit("-fasta must br provided if -w is used")
@@ -643,5 +808,5 @@ def main():
 
 if __name__ == "__main__":
     main()
-    print("Complete")
+    print("Done")
 

PyamilySeq-0.4.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.1
+Name: PyamilySeq
+Version: 0.4.0
+Summary: PyamilySeq - A a tool to look for sequence-based gene families identified by clustering methods such as CD-HIT, DIAMOND, BLAST or MMseqs2.
+Home-page: https://github.com/NickJD/PyamilySeq
+Author: Nicholas Dimonaco
+Author-email: nicholas@dimonaco.co.uk
+Project-URL: Bug Tracker, https://github.com/NickJD/PyamilySeq/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyamilySeq - !BETA!
+**PyamilySeq** (Family Seek) is a Python tool for clustering gene sequences into families based on sequence similarity identified by tools such as CD-HIT, BLAST, DIAMOND or MMseqs2.
+This work is an extension of the gene family / pangenome tool developed for the StORF-Reporter publication in NAR (https://doi.org/10.1093/nar/gkad814).
+
+## Features
+- **End-to-End**: PyamilySeq can take a directory of GFF+FASTA files, run CD-HIT for clustering and process the results.
+- **Clustering**: Supports input from CD-HIT formatted files as well as CSV and TSV edge lists (-outfmt 6 from BLAST/DIAMOND).
+- **Reclustering**: Allows for the addition of new sequences post-initial clustering.
+- **Output**: Generates a gene 'Roary/Panaroo' formatted presence-absence CSV formatted file for downstream analysis.
+  - Align representative sequences using MAFFT.
+  - Output concatenated aligned sequences for downstream analysis.
+  - Optionally output sequences of identified families.
+
+
+### Installation
+PyamilySeq requires Python 3.6 or higher. Install using pip:
+
+```bash
+pip install PyamilySeq
+```
+
+## Usage - Menu
+```
+usage: PyamilySeq.py [-h] -id INPUT_DIR -od OUTPUT_DIR -it {separate,combined} -ns NAME_SPLIT -pid PIDENT -ld LEN_DIFF -co CLUSTERING_OUT -ct {CD-HIT,BLAST,DIAMOND,MMseqs2} [-w WRITE_FAMILIES] [-con CON_CORE] [-fasta FASTA] [-rc RECLUSTERED] [-st SEQUENCE_TAG] [-groups CORE_GROUPS]
+                     [-gpa GENE_PRESENCE_ABSENCE_OUT]
+                     ...
+
+PyamilySeq v0.4.0: PyamilySeq Run Parameters.
+
+positional arguments:
+  pyamilyseq_args       Additional arguments for PyamilySeq.
+
+options:
+  -h, --help            show this help message and exit
+
+Required Arguments:
+  -id INPUT_DIR         Directory containing GFF/FASTA files.
+  -od OUTPUT_DIR        Directory for all output files.
+  -it {separate,combined}
+                        Type of input files: 'separate' for separate FASTA and GFF files, 'combined' for GFF files with embedded FASTA sequences.
+  -ns NAME_SPLIT        Character used to split the filename and extract the genome name.
+  -pid PIDENT           Pident threshold for CD-HIT clustering.
+  -ld LEN_DIFF          Length difference (-s) threshold for CD-HIT clustering.
+  -co CLUSTERING_OUT    Output file for initial clustering.
+  -ct {CD-HIT,BLAST,DIAMOND,MMseqs2}
+                        Clustering format for PyamilySeq.
+
+Output Parameters:
+  -w WRITE_FAMILIES     Default - No output: Output sequences of identified families (provide levels at which to output "-w 99,95" - Must provide FASTA file with -fasta
+  -con CON_CORE         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
+  -fasta FASTA          FASTA file to use in conjunction with "-w" or "-con"
+
+Optional Arguments:
+  -rc RECLUSTERED       Clustering output file from secondary round of clustering
+  -st SEQUENCE_TAG      Default - "StORF": Unique identifier to be used to distinguish the second of two rounds of clustered sequences
+  -groups CORE_GROUPS   Default - ('99,95,15'): Gene family groups to use
+  -gpa GENE_PRESENCE_ABSENCE_OUT
+                        Default - False: If selected, a Roary formatted gene_presence_absence.csv will be created - Required for Coinfinder and other downstream tools
+```
+
+### Example Run End-to-End - 'genomes' is a test-directory containing GFF files with ##FASTA at the bottom
+
+```bash
+PyamilySeq -id .../genomes -it combined -ns _combined.gff3 -pid 0.90 -ld 0.60 -co testing_cd-hit -ct CD-HIT -od .../testing
+```
+
+```Calculating Groups
+Calculating Groups
+Gene Groups:
+first_core_99: 3103
+first_core_95: 0
+first_core_15: 3217
+first_core_0: 4808
+Total Number of Gene Groups (Including Singletons): 11128
+```
+
+

PyamilySeq-0.4.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+PyamilySeq/CD-Hit_StORF-Reporter_Cross-Genera_Builder.py,sha256=UzQ5iOKCNfurxmj1pnkowF11YfWBO5vnBCKxQK6goB8,26538
+PyamilySeq/Constants.py,sha256=971sO5fjptv27yRtg595ex8VuNURb2Nh4mFSdGx6HJ4,399
+PyamilySeq/PyamilySeq.py,sha256=Zy84pSBXY9EnMmk30SrfbQr9-SWYJ4rPHb9xbV3L9lU,8971
+PyamilySeq/PyamilySeq_Species.py,sha256=kTXeCgplHfCglii_g099zdt2iy0lc5wDX3k4HuSaIgo,39167
+PyamilySeq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PyamilySeq/combine_FASTA_with_genome_IDs.py,sha256=aMUVSk6jKnKX0g04RMM360QueZS83lRLqLLysBtQbLo,2009
+PyamilySeq-0.4.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+PyamilySeq-0.4.0.dist-info/METADATA,sha256=d0goQEGZZz_q6_sZUwoPr-h7FR-Ad7WmupIJuK8MTFc,4462
+PyamilySeq-0.4.0.dist-info/WHEEL,sha256=rWxmBtp7hEUqVLOnTaDOPpR-cZpCDkzhhcBce-Zyd5k,91
+PyamilySeq-0.4.0.dist-info/entry_points.txt,sha256=aEpNchWXaSR7_hGQqXYGtvXz14FgIcfFdXESpEhsvXg,58
+PyamilySeq-0.4.0.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
+PyamilySeq-0.4.0.dist-info/RECORD,,

{PyamilySeq-0.2.0.dist-info → PyamilySeq-0.4.0.dist-info}/WHEEL

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

PyamilySeq-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+PyamilySeq = PyamilySeq.PyamilySeq:main

PyamilySeq-0.2.0.dist-info/METADATA

@@ -1,101 +0,0 @@
-Metadata-Version: 2.1
-Name: PyamilySeq
-Version: 0.2.0
-Summary: PyamilySeq - A a tool to look for sequence-based gene families identified by clustering methods such as CD-HIT, DIAMOND, BLAST or MMseqs2.
-Home-page: https://github.com/NickJD/PyamilySeq
-Author: Nicholas Dimonaco
-Author-email: nicholas@dimonaco.co.uk
-Project-URL: Bug Tracker, https://github.com/NickJD/PyamilySeq/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# PyamilySeq
-PyamilySeq (Family Seek) is a Python tool for clustering gene sequences into families based on sequence similarity identified by tools such as CD-HIT, DIAMOND or MMseqs2.
-This work is an extension of the gene family / pangenome tool developed for the StORF-Reporter publication in NAR (https://doi.org/10.1093/nar/gkad814).
-
-## Features
-
-- **Clustering**: Supports input from CD-HIT formatted files as well as TSV and CSV Edge List formats.
-- **Reclustering**: Allows for the addition of new sequences post-initial clustering.
-- **Output**: Generates a gene 'Roary' presence-absence CSV formatted file for downstream analysis.
-
-## Installation
-
-PyamilySeq requires Python 3.6 or higher. Install dependencies using pip:
-
-```bash
-pip install PyamilySeq
-```
-
-## Usage - Menu
-```
-PyamilySeq_Species.py -h
-usage: PyamilySeq_Species.py [-h] -c CLUSTERS -f {CD-HIT,CSV,TSV} [-w WRITE_FAMILIES] [-fasta FASTA] [-rc RECLUSTERED] [-st SEQUENCE_TAG]
-                             [-groups CORE_GROUPS] [-gpa GENE_PRESENCE_ABSENCE_OUT] [-verbose {True,False}] [-v]
-
-PyamilySeq v0.2.0: PyamilySeq Run Parameters.
-
-Required Arguments:
-  -c CLUSTERS           Clustering output file from CD-HIT, TSV or CSV Edge List
-  -f {CD-HIT,CSV,TSV}   Which format to use (CD-HIT or Comma/Tab Separated Edge-List (such as MMseqs2 tsv output))
-
-Output Parameters:
-  -w WRITE_FAMILIES     Default - No output: Output sequences of identified families (provide levels at which to output "-w 99 95" - Must provide
-                        FASTA file with -fasta
-  -fasta FASTA          FASTA file to use in conjunction with "-w"
-
-Optional Arguments:
-  -rc RECLUSTERED       Clustering output file from secondary round of clustering
-  -st SEQUENCE_TAG      Default - "StORF": Unique identifier to be used to distinguish the second of two rounds of clustered sequences
-  -groups CORE_GROUPS   Default - ('99,95,90,80,15'): Gene family groups to use
-  -gpa GENE_PRESENCE_ABSENCE_OUT
-                        Default - False: If selected, a Roary formatted gene_presence_absence.csv will be created - Required for Coinfinder and other
-                        downstream tools
-
-Misc:
-  -verbose {True,False}
-                        Default - False: Print out runtime messages
-  -v                    Default - False: Print out version number and exit
-
-```
-
-### Clustering Analysis
-
-To perform clustering analysis:
-
-```bash
-python pyamilyseq.py -c clusters_file -f format
-```
-
-Replace `clusters_file` with the path to your clustering output file and `format` with one of: `CD-HIT`, `CSV`, or `TSV`.
-
-### Reclustering
-
-To add new sequences and recluster:
-
-```bash
-PyamilySeq -c clusters_file -f format --reclustered reclustered_file
-```
-
-Replace `reclustered_file` with the path to the file containing additional sequences.
-
-## Output
-
-PyamilySeq generates various outputs, including:
-
-- **Gene Presence-Absence File**: This CSV file details the presence and absence of genes across genomes.
-- **FASTA Files for Each Gene Family**:  
-
-## Gene Family Groups
-
-After analysis, PyamilySeq categorizes gene families into several groups:
-
-- **First Core**: Gene families present in all analysed genomes initially.
-- **Extended Core**: Gene families extended with additional sequences.
-- **Combined Core**: Gene families combined with both initial and additional sequences.
-- **Second Core**: Gene families identified only in the additional sequences.
-- **Only Second Core**: Gene families exclusively found in the additional sequences.

PyamilySeq-0.2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-PyamilySeq/CD-Hit_StORF-Reporter_Cross-Genera_Builder.py,sha256=UzQ5iOKCNfurxmj1pnkowF11YfWBO5vnBCKxQK6goB8,26538
-PyamilySeq/Constants.py,sha256=3Nr6JfUVt2eZT4M7fV-sz_bPXIvPgxIBT5nR76kCPIo,30
-PyamilySeq/PyamilySeq_Species.py,sha256=SCWeK7bEfnKLrfzliiOx7Jtmie8vvAXGtQE_PpJD5hY,31040
-PyamilySeq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-PyamilySeq/combine_FASTA_with_genome_IDs.py,sha256=aMUVSk6jKnKX0g04RMM360QueZS83lRLqLLysBtQbLo,2009
-PyamilySeq-0.2.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-PyamilySeq-0.2.0.dist-info/METADATA,sha256=FUiZzxQzqnOwokb7MflZCMUzK9JgFVUVzEvLBPAlpgk,4144
-PyamilySeq-0.2.0.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-PyamilySeq-0.2.0.dist-info/entry_points.txt,sha256=zGtA2Ycf0LG3PR7zuuT0wjaAKLFxtyGgBc0O_W7E250,66
-PyamilySeq-0.2.0.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
-PyamilySeq-0.2.0.dist-info/RECORD,,

PyamilySeq-0.2.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-PyamilySeq = PyamilySeq.PyamilySeq_Species:main