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

PyamilySeq/PyamilySeq_Species.py

@@ -4,16 +4,16 @@ from collections import OrderedDict,defaultdict
 import copy
 import math
 import sys
-import argparse
-import os
 from tempfile import NamedTemporaryFile
 
 
 
 try:
     from .Constants import *
+    from .utils import *
 except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
     from Constants import *
+    from utils import *
 
 
 def custom_sort_key(k, dict1, dict2):
@@ -33,7 +33,7 @@ def select_longest_gene(sequences):
     return longest_sequences
 
 
-def run_mafft_on_sequences(sequences, output_file):
+def run_mafft_on_sequences(options, 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:
@@ -44,17 +44,25 @@ def run_mafft_on_sequences(sequences, output_file):
     # 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
-            )
+            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 process_gene_families(directory, output_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)
@@ -72,7 +80,7 @@ def process_gene_families(directory, output_file):
 
             # 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)
+            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)
@@ -143,9 +151,9 @@ def read_fasta(fasta_file):
         for line in file:
             line = line.strip()
             if not line:
-                continue  # Skip empty lines
+                continue
             if line.startswith('>'):
-                current_sequence = line[1:]  # Remove '>' character
+                current_sequence = line[1:]
                 sequences[current_sequence] = ''
             else:
                 sequences[current_sequence] += line
@@ -384,9 +392,9 @@ def combined_clustering_CDHIT(options, genome_dict):
     return combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids, combined_pangenome_clusters_Second, unique_genomes
 
 def combined_clustering_Edge_List(options, genome_dict):
-    if options.format == 'TSV':
+    if options.cluster_format == 'TSV':
         separator = '\t'
-    elif options.format == 'CSV':
+    elif options.cluster_format == 'CSV':
         separator = ','
     unique_genomes = []
     cluster_id = 0
@@ -463,9 +471,9 @@ def combined_clustering_Edge_List(options, genome_dict):
 
 
 def cluster_EdgeList(options):
-    if options.format == 'TSV':
+    if options.cluster_format == 'TSV':
         separator = '\t'
-    elif options.format == 'CSV':
+    elif options.cluster_format == 'CSV':
         separator = ','
     cluster_id = 0
     last_rep = ''
@@ -548,9 +556,9 @@ def cluster_CDHIT(options):
 #@profile
 def cluster(options):
 
-    if options.format == 'CD-HIT':
+    if options.cluster_format == 'CD-HIT':
         genome_dict, pangenome_clusters_First, pangenome_clusters_First_sequences, reps = cluster_CDHIT(options)
-    elif options.format in ['TSV','CSV']:
+    elif options.cluster_format in ['TSV','CSV']:
         genome_dict, pangenome_clusters_First, pangenome_clusters_First_sequences, reps = cluster_EdgeList(options)
 
     ######################################
@@ -558,10 +566,10 @@ def cluster(options):
     ###
 
     if options.reclustered != None:
-        if options.format == 'CD-HIT':
+        if options.cluster_format == 'CD-HIT':
             combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids,combined_pangenome_clusters_Second,\
                 unique_genomes = combined_clustering_CDHIT(options, genome_dict)
-        if options.format == 'TSV':
+        if options.cluster_format == 'TSV':
             combined_pangenome_clusters_First_Second_clustered,not_Second_only_cluster_ids,combined_pangenome_clusters_Second,\
                 unique_genomes = combined_clustering_Edge_List(options, genome_dict)
         pangenome_clusters_Type = combined_clustering_counting(options, pangenome_clusters_First, reps, combined_pangenome_clusters_First_Second_clustered)
@@ -570,7 +578,7 @@ def cluster(options):
 
 
 
-    Number_Of_StORF_Extending_But_Same_Genomes = 0
+    Number_Of_Second_Extending_But_Same_Genomes = 0
 
     sorted_first_keys = sort_keys_by_values(pangenome_clusters_First, pangenome_clusters_First_sequences)
     pangenome_clusters_First_sorted = reorder_dict_by_keys(pangenome_clusters_First, sorted_first_keys)
@@ -594,7 +602,7 @@ def cluster(options):
         elif numbers[0] > 1 and numbers[3] >= 1:  # If unique Secondss combined multiple Firsts
             calc_multi_First_extended_Second_only_core(numbers[1], groups, cores, numbers[3])
         elif numbers[4] >= 1:
-            Number_Of_StORF_Extending_But_Same_Genomes += 1
+            Number_Of_Second_Extending_But_Same_Genomes += 1
         combined_pangenome_clusters_ONLY_Second_Type = defaultdict(list)
         combined_pangenome_clusters_Second_Type = defaultdict(list)
         for cluster, genomes in combined_pangenome_clusters_Second.items():
@@ -643,7 +651,7 @@ def cluster(options):
                                         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')
+        process_gene_families(options, os.path.join(input_dir, 'Gene_Families_Output'), 'concatonated_genes_aligned.fasta')
 
 
         # groups_dir = os.path.join(input_dir, 'Gene_Families_Output')
@@ -705,7 +713,7 @@ def cluster(options):
         # for core_gene_family in core_gene_families:
         #     found_sequences = {genome: False for genome in genomes}
         #
-        #     for fasta_file in fasta_files:
+        #     for fasta_file in fasta_files:f
         #         sequences = read_fasta(fasta_file)
         #         for header, sequence in sequences.items():
         #             genome = header.split('|')[0]
@@ -720,93 +728,3 @@ def cluster(options):
 
 
 
-def main():
-
-    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)
-
-    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)
-
-    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',
-                        required = False)
-    misc.add_argument('-v', action='store_true', dest='version',
-                        help='Default - False: Print out version number and exit',
-                        required=False)
-
-
-    options = parser.parse_args()
-    if options.clusters == None or options.format == None:
-        if options.version:
-            sys.exit(PyamilySeq_Version)
-        else:
-            exit('PyamilySeq: error: the following arguments are required: -c, -f')
-
-    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")
-
-
-    options.clusters = os.path.normpath(options.clusters)
-    options.clusters = os.path.realpath(options.clusters)
-    if options.reclustered:
-        options.reclustered = os.path.normpath(options.reclustered)
-        options.reclustered = os.path.realpath(options.reclustered)
-
-
-    options.core_groups = options.core_groups + ',0'
-
-    cluster(options)
-
-
-
-
-
-    print("Thank you for using PyamilySeq -- A detailed user manual can be found at https://github.com/NickJD/PyamilySeq\n"
-          "Please report any issues to: https://github.com/NickJD/PyamilySeq/issues\n#####")
-
-
-
-
-
-if __name__ == "__main__":
-    main()
-    print("Done")
-

PyamilySeq/Seq_Combiner.py

@@ -0,0 +1,44 @@
+import argparse
+
+
+try:
+    from .Constants import *
+    from .utils import *
+except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
+    from Constants import *
+    from utils import *
+
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Seq-Combiner ' + PyamilySeq_Version + ': Seq-Combiner Run Parameters.')
+    ### Required Arguments
+    required = parser.add_argument_group('Required Arguments')
+    required.add_argument('-input_dir', action='store', dest='input_dir',
+                          help='Directory location where the files are located.',
+                          required=True)
+    required.add_argument("-input_type", 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("-name_split", action="store", dest="name_split",
+                          help="substring used to split the filename and extract the genome name ('_combined.gff3' or '.gff').",
+                          required=True)
+    required.add_argument("-output_dir", action="store", dest="output_dir",
+                          help="Directory for all output files.",
+                          required=True)
+    required.add_argument("-output_name", action="store", dest="output_file",
+                          help="Output file name.",
+                          required=True)
+    options = parser.parse_args()
+
+    output_path = os.path.abspath(options.output_dir)
+    combined_out_file = os.path.join(output_path, options.output_file)
+
+    if options.input_type == 'separate':
+        read_separate_files(options.input_dir, options.name_split, )
+    else:
+        read_combined_files(options.input_dir, options.name_split, combined_out_file)
+
+if __name__ == "__main__":
+    main()

PyamilySeq/utils.py

@@ -0,0 +1,136 @@
+import subprocess
+import shutil
+import os
+import glob
+import collections
+
+
+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
+    if shutil.which(tool_name) is None:
+        return False
+
+    # Try running the tool to ensure it's executable
+    try:
+        subprocess.run([tool_name, '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+        return True
+    except subprocess.CalledProcessError:
+        return True  # The tool is installed and ran, even if it returns an error code
+    except FileNotFoundError:
+        return False  # This shouldn't happen due to the earlier check
+
+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 fix_path(path):
+    fixed_path = os.path.normpath(path)
+    fixed_path = os.path.realpath(fixed_path)
+    return fixed_path
+
+
+
+
+
+
+
+def read_separate_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]
+            corresponding_fasta_file = os.path.splitext(gff_file)[0] + '.fa'
+            if not os.path.exists(corresponding_fasta_file):
+                continue
+
+            gff_features = []
+            with open(gff_file, 'r') as file:
+                lines = file.readlines()
+                for line in lines:
+                    line_data = line.split('\t')
+                    if len(line_data) == 9:
+                        if line_data[2] == 'CDS':
+                            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]
+                            gff_features.append((contig, start, end, strand, feature,  seq_id))
+            fasta_dict = collections.defaultdict(str)
+            with open(corresponding_fasta_file, 'r') as file:
+                lines = file.readlines()
+                for line in lines:
+                    if line.startswith('>'):
+                        current_contig = line[1:].split()[0]
+                        fasta_dict[current_contig] = ['', '']
+                    else:
+                        fasta_dict[current_contig][0] += line.strip()
+
+            for contig, fasta in fasta_dict.items():
+                reverse_sequence = reverse_complement(fasta[0])
+                fasta_dict[contig][1] = reverse_sequence
+
+            if fasta_dict and gff_features:
+                for contig, start, end, strand, feature, seq_id in gff_features:
+                    if contig in fasta_dict:
+                        if strand == '+':
+                            full_sequence = fasta_dict[contig][0]
+                            cds_sequence = full_sequence[start - 1:end]
+                        elif strand == '-':
+                            corrected_start = max(len(fasta_dict[contig][0]) - int(end), 1)
+                            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]
+
+                        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):
+    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][0] +=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]
+                                strand = line_data[6]
+                                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, strand, feature,  seq_id))
+
+                for contig, fasta in fasta_dict.items():
+                    reverse_sequence = reverse_complement(fasta[0])
+                    fasta_dict[contig][1]=reverse_sequence
+
+                if fasta_dict and gff_features:
+                    for contig, start, end, strand, feature, seq_id in gff_features:
+                        if contig in fasta_dict:
+                            if strand == '+':
+                                full_sequence = fasta_dict[contig][0]
+                                cds_sequence = full_sequence[start - 1:end]
+                            elif strand == '-':
+                                corrected_start = max(len(fasta_dict[contig][0]) - int(end), 1)
+                                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]
+
+                            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")

PyamilySeq-0.5.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.1
+Name: PyamilySeq
+Version: 0.5.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] -run_mode {Full,Partial} -group_mode {Species,Genus}
+                     -clust_tool {CD-HIT} -output_dir OUTPUT_DIR
+                     [-input_type {separate,combined}] [-input_dir INPUT_DIR]
+                     [-name_split NAME_SPLIT] [-pid PIDENT]
+                     [-len_diff LEN_DIFF] [-cluster_file CLUSTER_FILE]
+                     [-reclustered RECLUSTERED] [-seq_tag SEQUENCE_TAG]
+                     [-groups CORE_GROUPS] [-w WRITE_FAMILIES] [-con CON_CORE]
+                     [-original_fasta ORIGINAL_FASTA]
+                     [-gpa GENE_PRESENCE_ABSENCE_OUT] [-verbose {True,False}]
+                     [-v]
+
+PyamilySeq v0.5.0: PyamilySeq Run Parameters.
+
+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?
+  -clust_tool {CD-HIT}  Clustering tool to use: CD-HIT, DIAMOND, BLAST or
+                        MMseqs2.
+  -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').
+  -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.
+
+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
+                        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
+  -groups CORE_GROUPS   Default - ('99,95,15'): Gene family groups to use
+
+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
+  -original_fasta ORIGINAL_FASTA
+                        FASTA file to use in conjunction with "-w" or "-con"
+                        when running in Partial Mode.
+  -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
+
+```
+
+### Examples: Below are two examples of running PyamilySeq in its two main modes.
+#### 'Full Mode': Will conduct clustering of sequences as part of PyamilySeq run
+```bash 
+PyamilySeq -id .../genomes -it combined -ns _combined.gff3 -pid 0.90 -ld 0.60 -co testing_cd-hit -ct CD-HIT -od .../testing
+```
+#### 'Partial Mode': Will take the output of a sequence clustering
+```bash
+PyamilySeq -run_mode Partial -group_mode Species -output_dir .../test_data/testing -cluster_file .../test_data/CD-HIT/combined_Ensmbl_pep_CD_90_60.clstr -clust_tool CD-HIT -original_fasta .../test_data/combined_Ensmbl_cds.fasta -gpa True -con True -w 99 -verbose True
+```
+
+```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
+```
+
+## 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:
+```bash
+usage: Seq_Combiner.py [-h] -input_dir INPUT_DIR -input_type {separate,combined} -name_split NAME_SPLIT -output_dir OUTPUT_DIR -output_name OUTPUT_FILE
+
+Seq-Combiner v0.5.0: Seq-Combiner Run Parameters.
+
+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}
+                        Type of input files: 'separate' for separate FASTA and GFF files, 'combined' for GFF files with embedded FASTA sequences.
+  -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.
+```

PyamilySeq-0.5.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+PyamilySeq/CD-Hit_StORF-Reporter_Cross-Genera_Builder.py,sha256=UzQ5iOKCNfurxmj1pnkowF11YfWBO5vnBCKxQK6goB8,26538
+PyamilySeq/Constants.py,sha256=H1GMMb0WK68bphZPfzCvdvvSi5BeQc80QL4igt17S94,31
+PyamilySeq/PyamilySeq.py,sha256=ONDjQZoR4YCdAoDq2Ufv8mcY_1ek1LPJF-OtS4gzXDs,11276
+PyamilySeq/PyamilySeq_Genus.py,sha256=JpLLu3QaahUHBe7E80xVHtFORGuyeUMOt9eiLN5uazc,31286
+PyamilySeq/PyamilySeq_Species.py,sha256=6LHEdp6Vndoder8dlVSuyUKHdCbo5Rbxea1rnncrceY,35172
+PyamilySeq/Seq_Combiner.py,sha256=bHEIR-MZODSGm8n69ZIN-XzEoct5WZ1kH5Xa6uKCu4Y,1972
+PyamilySeq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PyamilySeq/utils.py,sha256=KhEnwzgVZyUu_Q92ukRPUrVD2505xSg9NY6e75nUmPQ,6487
+PyamilySeq-0.5.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+PyamilySeq-0.5.0.dist-info/METADATA,sha256=II_Elm1hg0nTXjmnEnsct2e4l2KQ1xR2hcXgp1wEiJA,7649
+PyamilySeq-0.5.0.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+PyamilySeq-0.5.0.dist-info/entry_points.txt,sha256=QtXD1tmnLvRAkIpGWZgXm1lfLH8GGeCwxmgoHZaTp98,102
+PyamilySeq-0.5.0.dist-info/top_level.txt,sha256=J6JhugUQTq4rq96yibAlQu3o4KCM9WuYfqr3w1r119M,11
+PyamilySeq-0.5.0.dist-info/RECORD,,

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

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

{PyamilySeq-0.4.0.dist-info → PyamilySeq-0.5.0.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 PyamilySeq = PyamilySeq.PyamilySeq:main
+Seq-Combiner = PyamilySeq.Seq_Combiner:main