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

PyamilySeq/utils.py

@@ -3,8 +3,33 @@ import shutil
 import os
 import glob
 import collections
+from tempfile import NamedTemporaryFile
+import sys
 
 
+################### We are currently fixed using Table 11
+gencode = {
+      'ATA':'I', 'ATC':'I', 'ATT':'I', 'ATG':'M',
+      'ACA':'T', 'ACC':'T', 'ACG':'T', 'ACT':'T',
+      'AAC':'N', 'AAT':'N', 'AAA':'K', 'AAG':'K',
+      'AGC':'S', 'AGT':'S', 'AGA':'R', 'AGG':'R',
+      'CTA':'L', 'CTC':'L', 'CTG':'L', 'CTT':'L',
+      'CCA':'P', 'CCC':'P', 'CCG':'P', 'CCT':'P',
+      'CAC':'H', 'CAT':'H', 'CAA':'Q', 'CAG':'Q',
+      'CGA':'R', 'CGC':'R', 'CGG':'R', 'CGT':'R',
+      'GTA':'V', 'GTC':'V', 'GTG':'V', 'GTT':'V',
+      'GCA':'A', 'GCC':'A', 'GCG':'A', 'GCT':'A',
+      'GAC':'D', 'GAT':'D', 'GAA':'E', 'GAG':'E',
+      'GGA':'G', 'GGC':'G', 'GGG':'G', 'GGT':'G',
+      'TCA':'S', 'TCC':'S', 'TCG':'S', 'TCT':'S',
+      'TTC':'F', 'TTT':'F', 'TTA':'L', 'TTG':'L',
+      'TAC':'Y', 'TAT':'Y', 'TAA':'*', 'TAG':'*',
+      'TGC':'C', 'TGT':'C', 'TGA':'*', 'TGG':'W'}
+
+def translate_frame(sequence):
+    translate = ''.join([gencode.get(sequence[3 * i:3 * i + 3], 'X') for i in range(len(sequence) // 3)])
+    return translate
+
 def is_tool_installed(tool_name):
     """Check if a tool is installed and available in PATH."""
     # Check if the tool is in the system PATH
@@ -30,12 +55,81 @@ def fix_path(path):
     return fixed_path
 
 
+def wrap_sequence(sequence, width=60):
+    wrapped_sequence = []
+    for i in range(0, len(sequence), width):
+        wrapped_sequence.append(sequence[i:i + width])
+    return "\n".join(wrapped_sequence)
+
+
+def read_fasta(fasta_file):
+    sequences = {}
+    current_sequence = None
+    with open(fasta_file, 'r') as file:
+        for line in file:
+            line = line.strip()
+            if not line:
+                continue  # Skip empty lines
+            if line.startswith('>'):
+                current_sequence = line[1:]  # Remove '>' character
+                sequences[current_sequence] = ''
+            else:
+                sequences[current_sequence] += line
+    return sequences
 
 
+def reorder_dict_by_keys(original_dict, sorted_keys):
+    return {k: original_dict[k] for k in sorted_keys}
+def custom_sort_key(k, dict1, dict2):
+    return (len(dict1[k]), len(dict2[k]))
 
+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(options, sequences, output_file):
+    #print("Conducting MAFFT alignment.")
+    """Run mafft on the given sequences and write to output file."""
+    # Create a temporary input file for mafft
+    with NamedTemporaryFile('w', delete=False) as temp_input_file:
+        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:
+            if options.verbose == True:
+                subprocess.run(
+                    ['mafft', '--auto', temp_input_file_path],
+                    stdout=output_f,
+                    stderr=sys.stderr,
+                    check=True
+                )
+            else:
+                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 read_separate_files(input_dir, name_split, combined_out):
+
+
+
+def read_separate_files(input_dir, name_split, gene_ident, combined_out, translate):
     with open(combined_out, 'w') as combined_out_file:
         for gff_file in glob.glob(os.path.join(input_dir, '*' + name_split)):
             genome_name = os.path.basename(gff_file).split(name_split)[0]
@@ -45,15 +139,21 @@ def read_separate_files(input_dir, name_split, combined_out):
 
             gff_features = []
             with open(gff_file, 'r') as file:
+                seen_seq_ids = collections.defaultdict(int)
                 lines = file.readlines()
                 for line in lines:
                     line_data = line.split('\t')
                     if len(line_data) == 9:
-                        if line_data[2] == 'CDS':
+                        if any(gene_type in line_data[2] for gene_type in gene_ident):
                             contig = line_data[0]
                             feature = line_data[2]
                             strand = line_data[6]
                             start, end = int(line_data[3]), int(line_data[4])
+                            if seq_id in seen_seq_ids:
+                                seq_id += '_' + str(seen_seq_ids[seq_id])
+                                seen_seq_ids[seq_id] + 1
+                            else:
+                                seen_seq_ids[seq_id] = 1
                             seq_id = line_data[8].split('ID=')[1].split(';')[0]
                             gff_features.append((contig, start, end, strand, feature,  seq_id))
             fasta_dict = collections.defaultdict(str)
@@ -81,18 +181,20 @@ def read_separate_files(input_dir, name_split, combined_out):
                             corrected_stop = max(len(fasta_dict[contig][0]) - int(start - 1), 1)
                             full_sequence = fasta_dict[contig][1]
                             cds_sequence = full_sequence[corrected_start:corrected_stop]
-
+                        if translate == True:
+                            cds_sequence = translate_frame(cds_sequence)
                         wrapped_sequence = '\n'.join([cds_sequence[i:i + 60] for i in range(0, len(cds_sequence), 60)])
                         combined_out_file.write(f">{genome_name}|{seq_id}\n{wrapped_sequence}\n")
 
 
-def read_combined_files(input_dir, name_split, combined_out):
+def read_combined_files(input_dir, name_split, gene_ident, combined_out, translate):
     with open(combined_out, 'w') as combined_out_file:
         for gff_file in glob.glob(os.path.join(input_dir, '*' + name_split)):
             genome_name = os.path.basename(gff_file).split(name_split)[0]
             fasta_dict = collections.defaultdict(str)
             gff_features = []
             with open(gff_file, 'r') as file:
+                seen_seq_ids = collections.defaultdict(int)
                 lines = file.readlines()
                 fasta_section = False
                 for line in lines:
@@ -108,12 +210,17 @@ def read_combined_files(input_dir, name_split, combined_out):
                     else:
                         line_data = line.split('\t')
                         if len(line_data) == 9:
-                            if line_data[2] == 'CDS':
+                            if any(gene_type in line_data[2] for gene_type in gene_ident):
                                 contig = line_data[0]
                                 feature = line_data[2]
                                 strand = line_data[6]
                                 start, end = int(line_data[3]), int(line_data[4])
                                 seq_id = line_data[8].split('ID=')[1].split(';')[0]
+                                if seq_id in seen_seq_ids:
+                                    seq_id += '_' + str(seen_seq_ids[seq_id])
+                                    seen_seq_ids[seq_id] + 1
+                                else:
+                                    seen_seq_ids[seq_id] = 1
                                 gff_features.append((contig, start, end, strand, feature,  seq_id))
 
                 for contig, fasta in fasta_dict.items():
@@ -132,5 +239,91 @@ def read_combined_files(input_dir, name_split, combined_out):
                                 full_sequence = fasta_dict[contig][1]
                                 cds_sequence = full_sequence[corrected_start:corrected_stop]
 
+                            if translate == True:
+                                cds_sequence = translate_frame(cds_sequence)
                             wrapped_sequence = '\n'.join([cds_sequence[i:i + 60] for i in range(0, len(cds_sequence), 60)])
-                            combined_out_file.write(f">{genome_name}|{seq_id}\n{wrapped_sequence}\n")
+                            combined_out_file.write(f">{genome_name}|{seq_id}\n{wrapped_sequence}\n")
+
+
+def read_fasta_files(input_dir, name_split, combined_out, translate):
+    with open(combined_out, 'w') as combined_out_file:
+        for fasta_file in glob.glob(os.path.join(input_dir, '*' + name_split)):
+            genome_name = os.path.basename(fasta_file).split(name_split)[0]
+            fasta_dict = collections.defaultdict(str)
+            with open(fasta_file, 'r') as file:
+                lines = file.readlines()
+                for line in lines:
+                    if line.startswith('>'):
+                        current_seq = line[1:].split()[0]
+                        fasta_dict[current_seq] = ''
+                    else:
+                        fasta_dict[current_seq] +=line.strip()
+                for id, seq in fasta_dict.items():
+                    if translate == True:
+                        seq = translate_frame(seq)
+                    wrapped_sequence = '\n'.join([seq[i:i + 60] for i in range(0, len(seq), 60)])
+                    combined_out_file.write(f">{genome_name}|{id}\n{wrapped_sequence}\n")
+
+
+def write_groups(options,output_dir, key_order, cores, sequences, pangenome_clusters_First_sequences_sorted, combined_pangenome_clusters_Second_sequences):
+    # Create output directory if it doesn't exist
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    for key_prefix in key_order:
+        for key, values in cores.items():
+            if any(part in options.write_groups.split(',') for part in key.split('_')):
+                if key.startswith(key_prefix):
+                    for value in values:
+                        output_filename = f"{key}_{value}.fasta"
+                        if 'First' in key_prefix:
+                            sequences_to_write = pangenome_clusters_First_sequences_sorted[value]
+                        else: # combined_pangenome_clusters_Second_sequences is None if reclustered isn't being used
+                            sequences_to_write = combined_pangenome_clusters_Second_sequences[value]
+                            # Write sequences to output file that are in the sequences dictionary
+                        with open(os.path.join(output_dir, output_filename), 'w') as outfile:
+                            for header in sequences_to_write:
+                                if header in sequences:
+                                    outfile.write(f">{header}\n")
+                                    wrapped_sequence = wrap_sequence(sequences[header])
+                                    outfile.write(f"{wrapped_sequence}\n")
+                                else:
+                                    if options.verbose == True:
+                                        print("Sequence " + header + " Not found in original_fasta file.")
+
+def process_gene_families(options, directory, output_file):
+    """Process each gene family file to select the longest sequence per genome and concatenate aligned sequences."""
+    concatenated_sequences = {}
+    output_file = directory.replace('Gene_Families_Output',output_file)
+
+    # Iterate over each gene family file
+    for gene_file in os.listdir(directory):
+        if gene_file.endswith('.fasta'):
+            gene_path = os.path.join(directory, gene_file)
+
+            # Read sequences from the gene family file
+            sequences = read_fasta(gene_path)
+
+            # Select the longest sequence for each genome
+            longest_sequences = select_longest_gene(sequences)
+
+            # Run mafft on the longest sequences
+            aligned_file = f"{gene_file}_aligned.fasta"
+            run_mafft_on_sequences(options, {seq_id: seq for seq_id, seq in longest_sequences.values()}, aligned_file)
+
+            # Read aligned sequences and concatenate them
+            aligned_sequences = read_fasta(aligned_file)
+            for genome, aligned_seq in aligned_sequences.items():
+                genome_name = genome.split('|')[0]
+                if genome_name not in concatenated_sequences:
+                    concatenated_sequences[genome_name] = ""
+                concatenated_sequences[genome_name] += aligned_seq
+
+            # Clean up aligned file
+            os.remove(aligned_file)
+
+    # Write the concatenated sequences to the output file
+    with open(output_file, 'w') as out:
+        for genome, sequence in concatenated_sequences.items():
+            out.write(f">{genome}\n")
+            wrapped_sequence = wrap_sequence(sequence, 60)
+            out.write(f"{wrapped_sequence}\n")

PyamilySeq-0.7.0.dist-info/METADATA

@@ -0,0 +1,251 @@
+Metadata-Version: 2.1
+Name: PyamilySeq
+Version: 0.7.0
+Summary: PyamilySeq - A a tool to look for sequence-based gene groups identified by clustering methods such as CD-HIT, DIAMOND, BLAST or MMseqs2.
+Home-page: https://github.com/NickJD/PyamilySeq
+Author: Nicholas Dimonaco
+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** is a Python tool for clustering gene sequences into groups 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 input**: Supports input from CD-HIT formatted files as well as CSV and TSV edge lists (MMseqs2 and -outfmt 6 from BLAST/DIAMOND).
+- **Reclustering**: Allows for the addition of new sequences post-initial clustering - Ensures continuity of contemporary clustering results and highlights impact of novel gene predictions.
+- **'Genus Mode'**: Unlike other 'pangenome' tools, PyamilySeq can identify gene groups found across multiple genera as unique entities (see below).  
+- **Output**: Generates a 'Roary/Panaroo' formatted presence-absence CSV formatted file for downstream analysis.
+  - User-define species-/genus-wide gene groups - User has control over grouping parameters (core = 99/95% or min 6 genera etc).
+  - Aligns representative sequences using MAFFT.
+  - Output concatenated aligned sequences for tree building.
+  - Optionally output sequences of each separate identified gene group.
+
+## Installation
+PyamilySeq probably requires Python 3.6 or higher. Install using pip:
+
+```bash
+pip install PyamilySeq
+```
+
+## Example usage: Below are two examples of running PyamilySeq in its two main modes.
+### 'Full Mode': Will conduct clustering of sequences with CD-HIT as part of PyamilySeq run
+```
+PyamilySeq -run_mode Full -group_mode Species -clustering_format CD-HIT  -output_dir .../test_data/testing/Full 
+-input_type combined -input_dir .../test_data/genomes -name_split _combined.gff3 -pid 0.95 -len_diff 0.80 
+-gpa -a -w 99
+```
+### 'Partial Mode': Will take the output of a sequence clustering.
+```
+PyamilySeq -run_mode Partial -group_mode Species -clustering_format TSV -output_dir .../test_data/Species/testing/Partial 
+-cluster_file .../test_data/Species/MMseqs2/combined_Ensmbl_pep_cluster.tsv 
+-original_fasta .../test_data/species/combined_Ensmbl_cds.fasta -gpa -a -w 99 -verbose 
+
+```
+#### Note: '-clustering_format TSV/CSV' requires input to be two in two columns as below (Same format as MMseqs2 tsv) - Genome name and sequence name are separated by '|'.
+```
+Escherichia_coli_110957|ENSB:lL-zIKt-gh0oSno	Escherichia_coli_110957|ENSB:lL-zIKt-gh0oSno
+Escherichia_coli_110957|ENSB:lL-zIKt-gh0oSno	Escherichia_coli_113290|ENSB:2fj4rJ8e8Z9PNdX
+Escherichia_coli_110957|ENSB:lL-zIKt-gh0oSno	Escherichia_coli_b185|ENSB:G_PVe28-ej8q-3S
+Escherichia_coli_110957|ENSB:TIZS9kbTvShDvyX	Escherichia_coli_110957|ENSB:TIZS9kbTvShDvyX
+```
+### Example output:
+```
+Running PyamilySeq v0.7.0
+Calculating Groups
+Gene Groups:
+First_core_99: 2682
+First_core_95: 0
+First_core_15: 3789
+First_core_0: 6469
+Total Number of First Gene Groups (Including Singletons): 12940
+Outputting gene_presence_absence file
+Outputting gene group FASTA files
+Processing gene group alignment
+Thank you for using PyamilySeq -- A detailed user manual can be found at https://github.com/NickJD/PyamilySeq
+Please report any issues to: https://github.com/NickJD/PyamilySeq/issues
+```
+## Genus mode: 
+### In addition to "Species mode" (see above) which reports gene groups the same as pangenome tools such as Roary and Panaroo, Genus mode reports gene groups identified across multiple genera.
+#### Example:
+```
+PyamilySeq -run_mode Partial -group_mode Genus -clustering_format CD-HIT -output_dir .../test_data/genus/testing/
+ -cluster_file .../test_data/genus/CD-HIT/combined_cds_cd-hit_80_60.clstr -gpa 
+```
+```commandline
+Running PyamilySeq v0.7.0
+Calculating Groups
+Genus Groups:
+First_genera_1:	28549
+First_genera_2:	12
+First_genera_3:	0
+First_genera_>:	0
+Total Number of First Gene Groups (Including Singletons): 28561
+Outputting gene_presence_absence file
+Thank you for using PyamilySeq -- A detailed user manual can be found at https://github.com/NickJD/PyamilySeq
+Please report any issues to: https://github.com/NickJD/PyamilySeq/issues
+#####
+```
+
+## Reclustering:
+### Reclustering can be used to see where additional sequences/genes lay in relation to a contemporary pangenome/gene grouping.
+```
+PyamilySeq -run_mode Partial -group_mode Species -clustering_format CD-HIT -output_dir .../test_data/species/CD-HIT/testing 
+-cluster_file .../test_data/species/CD-HIT/E-coli_extracted_cds_cd-hit_90_60.clstr -gpa 
+-reclustered .../test_data/species/CD-HIT/E-coli_extracted_cds_cd-hit_90_60_And_StORFs_cds_90_60.clstr
+```
+#### As can be seen below, the additional sequences recovered by the StORF-Reporter annotation tool have 'extended' contemporary or created entirely new gene groups. 'First' corresponds to the groups identified from the first clustering round and 'Second' for the second. In 'reclustering' mode, First_core_# groups are unaffected thus retaining the initial grouping information. 
+```commandline
+Running PyamilySeq v0.7.0
+Calculating Groups
+Gene Groups:
+First_core_99: 69
+First_core_95: 1002
+First_core_15: 4716
+First_core_0: 37960
+extended_core_99: 6
+extended_core_95: 73
+extended_core_15: 331
+extended_core_0: 582
+combined_core_99: 4
+combined_core_95: 88
+combined_core_15: 455
+combined_core_0: 228
+Second_core_99: 0
+Second_core_95: 5
+Second_core_15: 254
+Second_core_0: 3714
+only_Second_core_99: 6
+only_Second_core_95: 364
+only_Second_core_15: 3950
+only_Second_core_0: 31269
+Total Number of First Gene Groups (Including Singletons): 43747
+Total Number of Second Gene Groups (Including Singletons): 66525
+Total Number of First Gene Groups That Had Additional Second Sequences But Not New Genomes: 9593
+Outputting gene_presence_absence file
+Thank you for using PyamilySeq -- A detailed user manual can be found at https://github.com/NickJD/PyamilySeq
+Please report any issues to: https://github.com/NickJD/PyamilySeq/issues
+#####
+```
+
+## PyamilySeq - Menu: 
+### PyamilySeq is separated into two main 'run modes', Full and Partial. They each have their own set of required and optional arguments. 
+```
+Running PyamilySeq v0.7.0
+usage: PyamilySeq.py [-h] -run_mode {Full,Partial} -group_mode {Species,Genus} -clustering_format {CD-HIT,TSV,CSV} -output_dir OUTPUT_DIR
+                     [-input_type {separate,combined}] [-input_dir INPUT_DIR] [-name_split NAME_SPLIT] [-sequence_type {AA,DNA}] [-gene_ident GENE_IDENT]
+                     [-pid PIDENT] [-len_diff LEN_DIFF] [-mem CLUSTERING_MEMORY] [-t CLUSTERING_THREADS] [-cluster_file CLUSTER_FILE]
+                     [-reclustered RECLUSTERED] [-seq_tag SEQUENCE_TAG] [-core_groups CORE_GROUPS] [-genus_groups GENUS_GROUPS] [-w WRITE_GROUPS] [-a]
+                     [-original_fasta ORIGINAL_FASTA] [-gpa] [-verbose] [-v]
+
+PyamilySeq v0.7.0: A tool that groups genes into unique clusters.
+
+options:
+  -h, --help            show this help message and exit
+
+Required Arguments:
+  -run_mode {Full,Partial}
+                        Run Mode: Should PyamilySeq be run in "Full" or "Partial" mode?
+  -group_mode {Species,Genus}
+                        Group Mode: Should PyamilySeq be run in "Species" or "Genus" mode?
+  -clustering_format {CD-HIT,TSV,CSV}
+                        Clustering format to use: CD-HIT or TSV (MMseqs2, BLAST, DIAMOND) / CSV edge-list file (Node1 Node2).
+  -output_dir OUTPUT_DIR
+                        Directory for all output files.
+
+Full-Mode Arguments - Required when "-run_mode Full" is used:
+  -input_type {separate,combined}
+                        Type of input files: 'separate' for separate FASTA and GFF files, 'combined' for GFF files with embedded FASTA sequences.
+  -input_dir INPUT_DIR  Directory containing GFF/FASTA files.
+  -name_split NAME_SPLIT
+                        substring used to split the filename and extract the genome name ('_combined.gff3' or '.gff').
+  -sequence_type {AA,DNA}
+                        Default - DNA: Should clustering be performed in "DNA" or "AA" mode?
+  -gene_ident GENE_IDENT
+                        Identifier used for extraction of sequences such as
+                        "misc_RNA,gene,mRNA,CDS,rRNA,tRNA,tmRNA,CRISPR,ncRNA,regulatory_region,oriC,pseudo"
+  -pid PIDENT           Default 0.95: Pident threshold for clustering.
+  -len_diff LEN_DIFF    Default 0.80: Minimum length difference between clustered sequences - (-s) threshold for CD-HIT clustering.
+
+Clustering Runtime Arguments - Optional when "-run_mode Full" is used:
+  -mem CLUSTERING_MEMORY
+                        Default 4000: Memory to be allocated for clustering (in MBs).
+  -t CLUSTERING_THREADS
+                        Default 4: Threads to be allocated for clustering.
+
+Partial-Mode Arguments - Required when "-run_mode Partial" is used:
+  -cluster_file CLUSTER_FILE
+                        Clustering output file containing CD-HIT, TSV or CSV Edge List
+
+Grouping Arguments - Use to fine-tune grouping of genes after clustering:
+  -reclustered RECLUSTERED
+                        Currently only works on Partial Mode: Clustering output file from secondary round of clustering.
+  -seq_tag SEQUENCE_TAG
+                        Default - "StORF": Unique identifier to be used to distinguish the second of two rounds of clustered sequences
+  -core_groups CORE_GROUPS
+                        Default - ('99,95,15'): Gene family groups to use for "Species" mode
+  -genus_groups GENUS_GROUPS
+                        Default - ('1,2,3,4,5,6'): Gene family groups to use for "Genus" mode
+
+Output Parameters:
+  -w WRITE_GROUPS       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.
+  -a                    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 Partialrun mode.
+  -original_fasta ORIGINAL_FASTA
+                        FASTA file to use in conjunction with "-w" or "-con" when running in Partial Mode.
+  -gpa                  Default - False: If selected, a Roary/Panaroo formatted gene_presence_absence.csv will be created - Required for Coinfinder and
+                        other downstream tools
+
+Misc:
+  -verbose              Default - False: Print out runtime messages
+  -v                    Default - False: Print out version number and exit
+```
+
+
+
+
+
+## Seq-Combiner: This tool is provided to enable the pre-processing of multiple GFF/FASTA files together ready to be clustered by the user.
+### Example:
+```bash
+Seq-Combiner -input_dir .../test_data/genomes -name_split _combined.gff3 -output_dir.../test_data -output_name combine_fasta_seqs.fa -input_type combined
+```
+### Seq-Combiner Menu:
+```
+usage: Seq_Combiner.py [-h] -input_dir INPUT_DIR -input_type {separate,combined,fasta} -name_split NAME_SPLIT -output_dir OUTPUT_DIR -output_name OUTPUT_FILE [-gene_ident GENE_IDENT] [-translate] [-v]
+
+Seq-Combiner v0.7.0: A tool to extract sequences from GFF/FASTA files.
+
+options:
+  -h, --help            show this help message and exit
+
+Required Arguments:
+  -input_dir INPUT_DIR  Directory location where the files are located.
+  -input_type {separate,combined,fasta}
+                        Type of input files: "separate" for separate FASTA and GFF files, "combined" for GFF files with embedded FASTA sequences and "fasta" for combining multiple FASTA files together.
+  -name_split NAME_SPLIT
+                        substring used to split the filename and extract the genome name ('_combined.gff3' or '.gff').
+  -output_dir OUTPUT_DIR
+                        Directory for all output files.
+  -output_name OUTPUT_FILE
+                        Output file name.
+
+Optional Arguments:
+  -gene_ident GENE_IDENT
+                        Default - "CDS": Identifier used for extraction of sequences such as "misc_RNA,gene,mRNA,CDS,rRNA,tRNA,tmRNA,CRISPR,ncRNA,regulatory_region,oriC,pseudo" - Not compatible with "fasta" input mode.
+  -translate            Default - False: Translate extracted sequences to their AA counterpart?
+
+Misc Arguments:
+  -v                    Print out version number and exit
+
+
+```
+### All example input and output data can be found  in the 'test_data' directory.

PyamilySeq-0.7.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+PyamilySeq/Constants.py,sha256=RSX5-UuBXOrbEv3ETN415RwqoB6WmNe5eD-p7L15CJA,31
+PyamilySeq/PyamilySeq.py,sha256=wmdOVxxRKqsamsEWgnVVCYETUaYOEQQVYERpClrg4Zw,15203
+PyamilySeq/PyamilySeq_Genus.py,sha256=ZjD61mTW7NgmsfGfFVEXeIZoSCha9PaLtMPnqdTtacU,12413
+PyamilySeq/PyamilySeq_Species.py,sha256=WL6pu8hlGpnemcpu1tLFmlUlPd4vJpQSW4Om5Hclu_k,14438
+PyamilySeq/Seq_Combiner.py,sha256=dPDu6LlT3B-ZDn3wKZ3AeWraDgv2Tub_16l9CLc3tQ0,3353
+PyamilySeq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PyamilySeq/clusterings.py,sha256=rcWFv0IiWoS4aUNRjDDwNEL86l1wIKa4vK4htAxy8Hg,18787
+PyamilySeq/utils.py,sha256=-0OZxmX96kOTzms8gnbFBvc5DL6NsqNHNpLpQ4UjNk8,15726
+PyamilySeq-0.7.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+PyamilySeq-0.7.0.dist-info/METADATA,sha256=JDhA1JdFaESNwtqzWjRgaA92lrmVFNJWQZUonHgJuvA,13105
+PyamilySeq-0.7.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+PyamilySeq-0.7.0.dist-info/entry_points.txt,sha256=QtXD1tmnLvRAkIpGWZgXm1lfLH8GGeCwxmgoHZaTp98,102
+PyamilySeq-0.7.0.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
+PyamilySeq-0.7.0.dist-info/RECORD,,

{PyamilySeq-0.5.2.dist-info → PyamilySeq-0.7.0.dist-info}/WHEEL

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