added a new argument, -d and --delimiter, for users to specify what delimiter they are using in their FASTA and NEWICK tree files.

Author: JLSteenwyk

Makefile

@@ -31,4 +31,4 @@ coverage.unit:
 coverage.integration:
 	rm tests/samples/OG0000010.renamed.fa.mafft.clipkit.orthosnap.*
 	python -m pytest --basetemp=output --cov=./ -m "integration" --cov-report=xml:integration.coverage.xml
-	rm tests/samples/OG0000010.renamed.fa.mafft.clipkit.orthosnap.*
+	rm tests/samples/OG0000010.renamed.fa.mafft.clipkit.orthosnap.*

docs/change_log/index.rst

@@ -8,6 +8,9 @@ Change log
 
 Major changes to OrthoSNAP are summarized here.
 
+**1.3.2**
+Added argument for user-defined delimiter (-d, \-\-delimiter)
+
 **1.2.0**
 Added the -rih (\-\-report_inparalog_handling) function, which creates
 a summary file of which inparalogs where kept compared to trimmed

docs/usage/index.rst

@@ -97,6 +97,22 @@ To generate this file, use the following command:
 
 |
 
+Specifying the delimiter
+------------------------
+
+As of version 1.3.2, OrthoSNAP supports an argument for user-defined delimiters between
+the taxon name and gene name.
+
+By default, the delimiter is a pipe character (or "|"), but can be changed by setting the
+-d/\-\-delimiter argument. For example, if "-" is the current delimiter between taxon and
+gene names, use the following command:
+
+.. code-block:: shell
+
+   $ orthosnap -f orthogroup_of_genes.faa -t phylogeny_of_orthogroup_of_genes.tre -d -
+
+|
+
 All options
 -----------
 
@@ -115,6 +131,8 @@ All options
 +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
 | -r/\-\-roooted                      | boolean argument for whether the input phylogeny is already rooted (default: false)                                                          |
 +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
+| -d/\-\-delimiter                    | specify the delimiter found between taxon names and gene names (default: "|")                                                                |
++-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
 | -st/\-\-snap_trees                  | boolean argument for whether trees of SNAP-OGs should be outputted (default: false)                                                          |
 +-------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+
 | -ip/\-\-inparalog_to_keep           | determine which sequence to keep in the case of species-specific inparalogs using sequence- or tree-based options (default: longest_seq_len) |

orthosnap/args_processing.py

@@ -18,6 +18,8 @@ def process_args(args) -> dict:
     tree = args.tree
     fasta = args.fasta
 
+    delimiter = args.delimiter if args.delimiter is not None else "|"
+
     if not os.path.isfile(tree):
         logger.warning("Input tree does not exist")
         sys.exit()
@@ -30,7 +32,7 @@ def process_args(args) -> dict:
     occupancy = (
         args.occupancy
         if args.occupancy is not None
-        else determine_occupancy_threshold(fasta)
+        else determine_occupancy_threshold(fasta, delimiter)
     )
 
     if occupancy <= 0:
@@ -74,15 +76,16 @@ def process_args(args) -> dict:
         inparalog_to_keep=inparalog_to_keep,
         report_inparalog_handling=report_inparalog_handling,
         output_path=output_path,
+        delimiter=delimiter,
     )
 
 
-def determine_occupancy_threshold(fasta: str) -> int:
+def determine_occupancy_threshold(fasta: str, delimiter: str) -> int:
     fasta = SeqIO.parse(fasta, "fasta")
     unique_names = []
 
     for i in fasta:
-        i = i.id.split("|", 1)[0]
+        i = i.id.split(delimiter, 1)[0]
         if i not in unique_names:
             unique_names.append(i)
 

orthosnap/helper.py

@@ -3,6 +3,7 @@
 from enum import Enum
 import re
 import statistics as stat
+import sys
 
 from Bio import Phylo
 from Bio import SeqIO
@@ -28,7 +29,11 @@ def collapse_low_support_bipartitions(newtree, support: float):
     return newtree
 
 
-def determine_if_dups_are_sister(subtree_tips: list, newtree):
+def determine_if_dups_are_sister(
+    subtree_tips: list,
+    newtree,
+    delimiter: str,
+):
     """
     determine if dups are sister to one another
     """
@@ -41,7 +46,7 @@ def determine_if_dups_are_sister(subtree_tips: list, newtree):
     dup_tree = copy.deepcopy(newtree)
 
     dup_tree = dup_tree.common_ancestor(subtree_tips)
-    _, all_tips = get_all_tips_and_taxa_names(dup_tree)
+    _, all_tips = get_all_tips_and_taxa_names(dup_tree, delimiter)
     if set(all_tips) != set(subtree_tips):
         are_sisters = False
 
@@ -55,7 +60,7 @@ def determine_if_dups_are_sister(subtree_tips: list, newtree):
     return are_sisters
 
 
-def get_all_tips_and_taxa_names(tree):
+def get_all_tips_and_taxa_names(tree, delimiter: str):
     """
     get all taxa and tip names in a phylogeny
 
@@ -66,7 +71,11 @@ def get_all_tips_and_taxa_names(tree):
 
     # loop through the tree and collect terminal names
     for term in tree.get_terminals():
-        taxa_name = term.name[: term.name.index("|")]
+        try:
+            taxa_name = term.name[: term.name.index(delimiter)]
+        except ValueError:
+            print("\nERROR: Delimiter does not exist in FASTA headers.\nSpecify the delimiter using the -d argument.")
+            sys.exit()
         if taxa_name not in taxa:
             taxa.append(taxa_name)
         all_tips.append(term.name)
@@ -86,15 +95,15 @@ def check_if_single_copy(taxa: list, all_tips: list):
         return False
 
 
-def get_tips_and_taxa_names_and_taxa_counts_from_subtrees(inter):
+def get_tips_and_taxa_names_and_taxa_counts_from_subtrees(inter, delimiter: str):
     """
     get taxa, counts of each taxa, and all terminal names
     """
     taxa_from_terms = []
     terms = []
     # get taxa and terminal names from subtree
     for term in inter.get_terminals():
-        taxa_from_terms.append(term.name.split("|", 1)[0])
+        taxa_from_terms.append(term.name.split(delimiter, 1)[0])
         terms.append(term.name)
     # count number of taxa in subtree
     counts_of_taxa_from_terms = Counter(taxa_from_terms)
@@ -145,6 +154,7 @@ def handle_multi_copy_subtree(
     output_path: str,
     inparalog_handling: dict,
     inparalog_handling_summary: dict,
+    delimiter: str,
 ):
     """
     handling case where subtree contains all single copy genes
@@ -165,7 +175,9 @@ def handle_multi_copy_subtree(
 
             # check if subtrees are sister to one another
             # are_sisters = determine_if_dups_are_sister(subtree_tips)
-            are_sisters = determine_if_dups_are_sister(dups, newtree)
+            are_sisters = determine_if_dups_are_sister(
+                dups, newtree, delimiter
+            )
 
             # if duplicate sequences are sister, get the longest sequence
             if are_sisters:
@@ -179,7 +191,7 @@ def handle_multi_copy_subtree(
     # if the resulting subtree has only single copy genes
     # create a fasta file with sequences from tip labels
     _, _, _, counts = \
-        get_tips_and_taxa_names_and_taxa_counts_from_subtrees(newtree)
+        get_tips_and_taxa_names_and_taxa_counts_from_subtrees(newtree, delimiter)
 
     if set(counts) == set([1]):
         (

orthosnap/orthosnap.py

@@ -33,6 +33,7 @@ def execute(
     inparalog_to_keep: InparalogToKeep,
     report_inparalog_handling: bool,
     output_path: str,
+    delimiter: str,
 ):
     """
     Master execute Function
@@ -58,6 +59,7 @@ def execute(
         inparalog_to_keep,
         report_inparalog_handling,
         output_path,
+        delimiter,
     )
 
     # create start time logger
@@ -67,7 +69,7 @@ def execute(
     tree, fasta_dict = read_input_files(tree, fasta, rooted)
 
     # get list of all tip names and taxa names
-    taxa, all_tips = get_all_tips_and_taxa_names(tree)
+    taxa, all_tips = get_all_tips_and_taxa_names(tree, delimiter)
 
     # check if the inputted phylogeny is already a single-copy tree.
     # if it is, exit
@@ -89,7 +91,9 @@ def execute(
             terms,
             counts_of_taxa_from_terms,
             counts,
-        ) = get_tips_and_taxa_names_and_taxa_counts_from_subtrees(inter)
+        ) = get_tips_and_taxa_names_and_taxa_counts_from_subtrees(
+            inter, delimiter
+        )
 
         # create a copy of the input tree
         newtree = copy.deepcopy(tree)
@@ -142,6 +146,7 @@ def execute(
                         output_path,
                         inparalog_handling,
                         inparalog_handling_summary,
+                        delimiter,
                     )
 
     if report_inparalog_handling:

orthosnap/parser.py

@@ -19,18 +19,19 @@ def create_parser():
         usage=SUPPRESS,
         description=textwrap.dedent(
             f"""\
-                   _   _                                 
-                  | | | |                                
-         ___  _ __| |_| |__   ___  ___ _ __   __ _ _ __  
-        / _ \| '__| __| '_ \ / _ \/ __| '_ \ / _` | '_ \ 
-       | (_) | |  | |_| | | | (_) \__ \ | | | (_| | |_) |
-        \___/|_|   \__|_| |_|\___/|___/_| |_|\__,_| .__/ 
-                                                  | |    
-                                                  |_|     
+         ____       _   _           _____ _   _          _____  
+        / __ \     | | | |         / ____| \ | |   /\   |  __ \ 
+       | |  | |_ __| |_| |__   ___| (___ |  \| |  /  \  | |__) |
+       | |  | | '__| __| '_ \ / _ \\___ \| . ` | / /\ \ |  ___/ 
+       | |__| | |  | |_| | | | (_) |___) | |\  |/ ____ \| |     
+        \____/|_|   \__|_| |_|\___/_____/|_| \_/_/    \_\_|                                                        
+                                                            
 
         Version: {__version__}
-        Citation: Steenwyk et al.
-        Usage: orthosnap <input> [optional arguments]
+        Citation: Steenwyk et al. (2022), PLOS Biology. DOI: 10.1371/journal.pbio.3001827.
+        https://journals.plos.org/plosbiology/article?id=10.1371/journal.pbio.3001827
+        
+        Usage: orthosnap -f <fasta_file> -t <newick_tree_file> [optional arguments]
         """
         ),
     )
@@ -89,6 +90,10 @@ def create_parser():
             boolean argument for whether the input phylogeny is already rooted
             default: false
 
+        -d, --delimiter
+            string for delimited between species and sequence name
+            default: "|"
+
         -st, --snap_trees
             boolean argument for whether trees of SNAP-OGs should be outputted
             default: false
@@ -149,6 +154,13 @@ def create_parser():
             - if used, the input phylogeny is assumed to be rooted; if not,
               the tree will be midpoint rooted
 
+        -d, --delimiter
+            - separator between taxon name and gene sequence
+            - the default is a pipe character (or "|")
+                - for example, a FASTA header may be as follows:
+                >species_A|gene0 to specify species_A and
+                gene identifier gene_0
+
         -st, --snap_trees
             - boolean argument for whether newick files of SNAP-OGs should also
               be outputted
@@ -205,6 +217,14 @@ def create_parser():
         help=SUPPRESS,
     )
 
+    optional.add_argument(
+        "-d",
+        "--delimiter",
+        type=str,
+        required=False,
+        help=SUPPRESS,
+    )
+
     optional.add_argument(
         "-st",
         "--snap_trees",

orthosnap/writer.py

@@ -15,6 +15,7 @@ def write_user_args(
     inparalog_to_keep: InparalogToKeep,
     report_inparalog_handling: bool,
     output_path: str,
+    delimiter: str,
 ):
     """
     Function to print user arguments to stdout
@@ -31,6 +32,7 @@ def write_user_args(
     Report inparalog handling: {report_inparalog_handling}
     Support threshold: {support}
     Taxon occupancy threshold: {occupancy}
+    Delimiter: {delimiter}
     Output newick of SNAP-OGs: {snap_trees}
     Output directory: {output_path}
     """