ssi-analysis-result-parsers 0.0.1__py3-none-any.whl

ssi_analysis_result_parsers/Legionella_parser.py

@@ -0,0 +1,88 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/39_Legionella_parser.ipynb.
+
+# %% auto 0
+__all__ = ['extract_legionella_sbt', 'legionella_summary', 'legionella_parser']
+
+# %% ../nbs/39_Legionella_parser.ipynb 3
+# standard libs
+import os
+import re
+
+# Common to template
+# add into settings.ini, requirements, package name is python-dotenv, for conda build ensure `conda config --add channels conda-forge`
+import dotenv  # for loading config from .env files, https://pypi.org/project/python-dotenv/
+import envyaml  # Allows to loads env vars into a yaml file, https://github.com/thesimj/envyaml
+import fastcore  # To add functionality related to nbdev development, https://github.com/fastai/fastcore/
+from fastcore import (
+    test,
+)
+from fastcore.script import (
+    call_parse,
+)  # for @call_parse, https://fastcore.fast.ai/script
+import json  # for nicely printing json and yaml
+
+# import functions from core module (optional, but most likely needed).
+from ssi_analysis_result_parsers import (
+    core,
+)
+from .blast_parser import extract_presence_absence
+
+# Project specific libraries
+from pathlib import Path
+import pandas
+import sys
+
+# %% ../nbs/39_Legionella_parser.ipynb 6
+def extract_legionella_sbt(legionella_sbt_results_tsv: Path) -> dict:
+    """
+    Returns dictionary of results found in the Legionella SBT summary output
+    """
+    if os.path.exists(legionella_sbt_results_tsv):
+        df = pandas.read_csv(legionella_sbt_results_tsv, sep="\t")
+        df.set_index("sample", inplace=True, drop=True)
+        d = df.to_dict(orient="index")
+        fname = next(iter(d))
+        return d[fname]
+    else:
+        print(
+            f"No Legionella SBT output found at {legionella_sbt_results_tsv}",
+            file=sys.stderr,
+        )
+        return None
+
+
+def legionella_summary(legionella_sbt_results_tsv: Path, lag1_blast_tsv: Path) -> dict:
+    sbt_results_dict = extract_legionella_sbt(
+        legionella_sbt_results_tsv=legionella_sbt_results_tsv
+    )
+    lag1_blast_dict = extract_presence_absence(
+        blast_output_tsv=lag1_blast_tsv,
+        hits_as_string=False,
+        include_match_stats=False,
+        gene_names=["lag-1"],
+    )
+    results_dict = core.update_results_dict(
+        sbt_results_dict, lag1_blast_dict, old_duplicate_key_prefix="SBT: "
+    )
+    return results_dict
+
+# %% ../nbs/39_Legionella_parser.ipynb 9
+@call_parse
+def legionella_parser(
+    legionella_sbt_file: Path = None,  # Path "*.sbt.tsv from legionella_sbt program"
+    lag_1_blast_output: Path = None,  #  Path to output from lag1_blast. Generated with blastn -query lag-1.fasta -subject assembly.fasta -outfmt "6 qseqid sseqid pident length qlen qstart qend sstart send sseq evalue bitscore"
+    output_file: Path = None,  # Path to output tsv
+    sample_name: str = None,
+    config_file: str = None,  # config file to set env vars from
+) -> None:
+    """ """
+    # config = core.get_config(config_file)  # Set env vars and get config variables
+    legionella_summary_dict = legionella_summary(
+        legionella_sbt_results_tsv=legionella_sbt_file,
+        lag1_blast_tsv=lag_1_blast_output,
+    )
+    core.print_results_dict_to_tsv(
+        results_dict=legionella_summary_dict,
+        output_file=output_file,
+        sample_name=sample_name,
+    )

ssi_analysis_result_parsers/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

ssi_analysis_result_parsers/_modidx.py

@@ -0,0 +1,38 @@
+# Autogenerated by nbdev
+
+d = { 'settings': { 'branch': 'main',
+                'doc_baseurl': '/ssi_analysis_result_parsers',
+                'doc_host': 'https://$GIT_USER_NAME.github.io',
+                'git_url': 'https://github.com/$GIT_USER_NAME/ssi_analysis_result_parsers',
+                'lib_path': 'ssi_analysis_result_parsers'},
+  'syms': { 'ssi_analysis_result_parsers.Legionella_parser': { 'ssi_analysis_result_parsers.Legionella_parser.extract_legionella_sbt': ( 'legionella_parser.html#extract_legionella_sbt',
+                                                                                                                                         'ssi_analysis_result_parsers/Legionella_parser.py'),
+                                                               'ssi_analysis_result_parsers.Legionella_parser.legionella_parser': ( 'legionella_parser.html#legionella_parser',
+                                                                                                                                    'ssi_analysis_result_parsers/Legionella_parser.py'),
+                                                               'ssi_analysis_result_parsers.Legionella_parser.legionella_summary': ( 'legionella_parser.html#legionella_summary',
+                                                                                                                                     'ssi_analysis_result_parsers/Legionella_parser.py')},
+            'ssi_analysis_result_parsers.blast_parser': { 'ssi_analysis_result_parsers.blast_parser.allele_matches': ( 'blast_parser.html#allele_matches',
+                                                                                                                       'ssi_analysis_result_parsers/blast_parser.py'),
+                                                          'ssi_analysis_result_parsers.blast_parser.extract_allele_matches': ( 'blast_parser.html#extract_allele_matches',
+                                                                                                                               'ssi_analysis_result_parsers/blast_parser.py'),
+                                                          'ssi_analysis_result_parsers.blast_parser.extract_presence_absence': ( 'blast_parser.html#extract_presence_absence',
+                                                                                                                                 'ssi_analysis_result_parsers/blast_parser.py'),
+                                                          'ssi_analysis_result_parsers.blast_parser.presence_absence': ( 'blast_parser.html#presence_absence',
+                                                                                                                         'ssi_analysis_result_parsers/blast_parser.py')},
+            'ssi_analysis_result_parsers.core': { 'ssi_analysis_result_parsers.core.get_config': ( 'core.html#get_config',
+                                                                                                   'ssi_analysis_result_parsers/core.py'),
+                                                  'ssi_analysis_result_parsers.core.get_samplesheet': ( 'core.html#get_samplesheet',
+                                                                                                        'ssi_analysis_result_parsers/core.py'),
+                                                  'ssi_analysis_result_parsers.core.print_results_dict_to_tsv': ( 'core.html#print_results_dict_to_tsv',
+                                                                                                                  'ssi_analysis_result_parsers/core.py'),
+                                                  'ssi_analysis_result_parsers.core.set_env_variables': ( 'core.html#set_env_variables',
+                                                                                                          'ssi_analysis_result_parsers/core.py'),
+                                                  'ssi_analysis_result_parsers.core.show_project_env_vars': ( 'core.html#show_project_env_vars',
+                                                                                                              'ssi_analysis_result_parsers/core.py'),
+                                                  'ssi_analysis_result_parsers.core.update_results_dict': ( 'core.html#update_results_dict',
+                                                                                                            'ssi_analysis_result_parsers/core.py')},
+            'ssi_analysis_result_parsers.hello_world': { 'ssi_analysis_result_parsers.hello_world.cli': ( 'hello_world.html#cli',
+                                                                                                          'ssi_analysis_result_parsers/hello_world.py'),
+                                                         'ssi_analysis_result_parsers.hello_world.hello_world': ( 'hello_world.html#hello_world',
+                                                                                                                  'ssi_analysis_result_parsers/hello_world.py')},
+            'ssi_analysis_result_parsers.some_string': {}}}

ssi_analysis_result_parsers/blast_parser.py

@@ -0,0 +1,178 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/11_blast_parser.ipynb.
+
+# %% auto 0
+__all__ = ['extract_presence_absence', 'extract_allele_matches', 'presence_absence', 'allele_matches']
+
+# %% ../nbs/11_blast_parser.ipynb 3
+# standard libs
+import os
+import re
+
+# Common to template
+# add into settings.ini, requirements, package name is python-dotenv, for conda build ensure `conda config --add channels conda-forge`
+import dotenv  # for loading config from .env files, https://pypi.org/project/python-dotenv/
+import envyaml  # Allows to loads env vars into a yaml file, https://github.com/thesimj/envyaml
+import fastcore  # To add functionality related to nbdev development, https://github.com/fastai/fastcore/
+from fastcore import (
+    test,
+)
+from fastcore.script import (
+    call_parse,
+)  # for @call_parse, https://fastcore.fast.ai/script
+import json  # for nicely printing json and yaml
+
+# import functions from core module (optional, but most likely needed).
+from . import core
+
+# Project specific libraries
+from pathlib import Path
+import pandas
+import sys
+
+# %% ../nbs/11_blast_parser.ipynb 6
+def extract_presence_absence(
+    blast_output_tsv: Path,
+    tsv_header: str = "qseqid sseqid pident length qlen qstart qend sstart send sseq evalue bitscore",
+    hits_as_string: bool = True,
+    include_match_stats=False,
+    pident_threshold: float = 90,
+    plen_threshold: float = 60,
+    gene_names: list = None,
+) -> dict:
+    """
+    Parse blast output tsv for best matching alleles
+    returns:
+    if include_match stats:
+        { <gene_name_1>: <allele_number>,  <gene_name_2>: <allele_number>,  <gene_name_3>: <allele_number> ...}
+    else:
+        a dictionary (allele_dict) in the format { <gene_name_1>: <allele_number>,  <gene_name_2>: <allele_number>,  <gene_name_3>: <allele_number> ...}
+
+    """
+    if os.path.exists(blast_output_tsv):
+        blast_df = pandas.read_csv(blast_output_tsv, sep="\t", header=None)
+        blast_df.columns = tsv_header.split(" ")
+        blast_df["plen"] = blast_df["length"] / blast_df["qlen"] * 100
+        blast_df_unique = (
+            blast_df.sort_values(by=["bitscore"], ascending=False)
+            .groupby("qseqid")
+            .first()
+        )
+        blast_df_filtered = blast_df_unique.query(
+            "plen > @plen_threshold and pident > @pident_threshold"
+        )
+        if hits_as_string:
+            if include_match_stats:
+                results = []
+                for gene, d in blast_df_filtered.to_dict(orient="index").items():
+                    results.append(f"{gene}__{d['pident']}__{d['plen']}")
+                result_dict = {"genes_found": ", ".join(results)}
+                return result_dict
+
+            else:
+                result_dict = {
+                    "genes_found": ", ".join(list(blast_df_filtered.index.values))
+                }
+                return result_dict
+
+        else:
+            result_dict = {}
+            blast_dict = dict(blast_df_filtered.to_dict(orient="index").items())
+            if gene_names is None:
+                gene_names = blast_dict.keys()
+            for gene in gene_names:
+                if gene in blast_dict:
+                    if include_match_stats:
+                        result_dict[gene] = (
+                            f"{blast_dict[gene]['pident']}__{blast_dict[gene]['plen']}"
+                        )
+                    else:
+                        result_dict[gene] = "1"
+                else:
+                    result_dict[gene] = "0"
+            return result_dict
+
+    else:
+        print(f"No blast output found at {blast_output_tsv}", file=sys.stderr)
+
+
+def extract_allele_matches(
+    blast_output_tsv: Path, tsv_header: str, include_match_stats=False
+) -> dict:
+    """
+    Parse blast output tsv for best matching alleles
+    returns:
+    if include_match stats:
+        { <gene_name_1>: <allele_number>__<pident>__<plen>,  <gene_name_2>: <allele_number>__<pident>__<plen>,  <gene_name_3>: <allele_number>__<pident>__<plen> ...}
+    else:
+        a dictionary (allele_dict) in the format { <gene_name_1>: <allele_number>,  <gene_name_2>: <allele_number>,  <gene_name_3>: <allele_number> ...}
+
+    """
+    allele_dict = {}
+    detailed_dict = {}
+    if os.path.exists(blast_output_tsv):
+        blast_df = pandas.read_csv(blast_output_tsv, sep="\t", header=None)
+        blast_df.columns = tsv_header.split(" ")
+        blast_df.set_index("qseqid", drop=False)
+        blast_df["plen"] = blast_df["length"] / blast_df["qlen"] * 100
+        blast_df[["gene", "allele"]] = blast_df["qseqid"].str.split("_", expand=True)
+        blast_df_unique = (
+            blast_df.sort_values(by=["bitscore"], ascending=False)
+            .groupby("gene")
+            .first()
+        )
+        for gene, d in blast_df_unique.to_dict(orient="index").items():
+            allele_dict[gene] = d["allele"]
+            detailed_dict[gene] = f"{d['allele']}__{d['pident']}__{d['plen']}"
+    else:
+        print(f"No blast output found at {blast_output_tsv}", file=sys.stderr)
+
+    if include_match_stats:
+        return detailed_dict
+    else:
+        return allele_dict
+
+# %% ../nbs/11_blast_parser.ipynb 9
+from fastcore.script import call_parse
+
+
+@call_parse
+def presence_absence(
+    blast_output: Path = None,  # Path to blast output file. Generated with --outfmt 6 option
+    blast_tsv_header: str = "qseqid sseqid pident length qlen qstart qend sstart send sseq evalue bitscore",  # headers in blast output
+    hits_as_string: bool = True,  # True to print a comma separated list of found genes on a single line. False to return a key: value pair for each gene
+    include_match_stats: bool = False,  # True to include percent identity and percent length in output, false to only include present/absent
+    percent_identityt: float = 90,  # percent identity threshold for considering a gene present
+    percent_length: float = 60,  # percent length threshold for considering a gene present
+    gene_names: list = None,  # name of genes to look for when hits_as_string = False
+    output_file: Path = None,
+    config_file: str = None,  # config file to set env vars from
+) -> None:
+    """ """
+    # config = core.get_config(config_file)  # Set env vars and get config variables
+    gene_presence_dict = extract_presence_absence(
+        blast_output_tsv=blast_output,
+        tsv_header=blast_tsv_header,
+        hits_as_string=hits_as_string,
+        include_match_stats=include_match_stats,
+        pident_threshold=percent_identityt,
+        plen_threshold=percent_length,
+        gene_names=gene_names,
+    )
+
+
+@call_parse
+def allele_matches(
+    blast_output: Path = None,  # Path to blast output file. Generated with --outfmt 6 option
+    blast_tsv_header: str = "qseqid sseqid pident length qlen qstart qend sstart send sseq evalue bitscore",  # headers in blast output
+    include_match_stats: bool = False,  # True to include percent identity and percent length in output, false to only include allele number
+    output_file: Path = None,
+    config_file: str = None,  # config file to set env vars from
+) -> None:
+    """ """
+    # config = core.get_config(config_file)  # Set env vars and get config variables
+    allele_dict = extract_allele_matches(
+        blast_output_tsv=blast_output,
+        tsv_header=blast_tsv_header,
+        include_match_stats=include_match_stats,
+        output_file=None,
+    )

ssi_analysis_result_parsers/config/config.default.env

@@ -0,0 +1,24 @@
+# environmental (ENV) variables. These are written as SSI_ANALYSIS_RESULT_PARSERS_VARIABLENAME=VALUE to avoid conflicts with other ENV variables. 
+# Using the standard template these values can be overwritten by:
+# - defining SSI_ANALYSIS_RESULT_PARSERS_CONFIG_FILE pointing to a similar file with a subset of values
+# - setting the values as environmental variables.
+# The priority goes env variables > config file > default file.
+# The all configs other than config.default.env are in .gitignore
+# All .env config files should have an associated .yaml config file with it which the program interacts with.
+
+# NOTE: remember if referencing another ENV var as a variable it needs to be defined first
+
+# If more structured variables are needed use config.default.yaml or another of your own creation
+# This file path is stored as CORE_CONFIG_FILE when overriding
+# It is commented out because of the default use case, but should be included for all non default cases.
+# CORE_YAML_CONFIG_FILE=
+CORE_PROJECT_VARIABLE_PREFIX=SSI_ANALYSIS_RESULT_PARSERS_
+# For testing purposes
+CORE_TEST_VAR="Test"
+
+# Example variable please exchange with relevant variables
+SSI_ANALYSIS_RESULT_PARSERS_INPUT_DIR=./input
+SSI_ANALYSIS_RESULT_PARSERS_OUTPUT_DIR=./output
+SSI_ANALYSIS_RESULT_PARSERS_OUTPUT_FILE=${SSI_ANALYSIS_RESULT_PARSERS_OUTPUT_DIR}/output.txt
+SSI_ANALYSIS_RESULT_PARSERS_USER_INPUT_NAME=Kim
+

ssi_analysis_result_parsers/config/config.default.yaml

@@ -0,0 +1,9 @@
+# When accessing this in the code you'll work with it as a dict.
+# ENV variables will be replaced with their values. This is done with the envyaml package that is in the code template `load_config`.
+# By convention all variables for the project should have the SSI_ANALYSIS_RESULT_PARSERS_* prefix.
+# e.g
+# name: ${SSI_ANALYSIS_RESULT_PARSERS_NAME}
+example:
+    input:
+        name: ${SSI_ANALYSIS_RESULT_PARSERS_USER_INPUT_NAME}
+        alternative_name: Lee

ssi_analysis_result_parsers/core.py

@@ -0,0 +1,252 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/00_core.ipynb.
+
+# %% auto 0
+__all__ = ['PACKAGE_NAME', 'DEV_MODE', 'PACKAGE_DIR', 'PROJECT_DIR', 'config', 'set_env_variables', 'get_config',
+           'show_project_env_vars', 'get_samplesheet', 'update_results_dict', 'print_results_dict_to_tsv']
+
+# %% ../nbs/00_core.ipynb 4
+# Need the ssi_analysis_result_parsers for a few functions, this can be considered a static var
+
+import importlib
+import importlib.util
+import os
+
+PACKAGE_NAME: str = (
+    "ssi_analysis_result_parsers"  # Make sure to adjust this to your package name
+)
+DEV_MODE: bool = (
+    False  # set below to override, as this is in an export block it'll be exported while the dev mode section is not
+)
+
+PACKAGE_DIR = None
+try:
+    spec = importlib.util.find_spec(PACKAGE_NAME)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    PACKAGE_DIR = os.path.dirname(module.__file__)
+except ImportError:
+    DEV_MODE = True
+except AttributeError:
+    DEV_MODE = True
+PROJECT_DIR = os.getcwd()  # override value in dev mode
+if PROJECT_DIR.endswith("nbs"):
+    DEV_MODE = True
+    PROJECT_DIR = os.path.split(PROJECT_DIR)[0]
+
+# %% ../nbs/00_core.ipynb 10
+# standard libs
+import os
+import re
+
+# Common to template
+# add into settings.ini, requirements, package name is python-dotenv, for conda build ensure `conda config --add channels conda-forge`
+import dotenv  # for loading config from .env files, https://pypi.org/project/python-dotenv/
+import envyaml  # Allows to loads env vars into a yaml file, https://github.com/thesimj/envyaml
+import fastcore  # To add functionality related to nbdev development, https://github.com/fastai/fastcore/
+import pandas  # For sample sheet manipulation
+from fastcore import (
+    test,
+)
+from fastcore.script import (
+    call_parse,
+)  # for @call_parse, https://fastcore.fast.ai/script
+
+# Project specific libraries
+
+from pathlib import Path
+from hashlib import sha256
+
+# %% ../nbs/00_core.ipynb 13
+import importlib
+import importlib.util
+
+
+def set_env_variables(config_path: str, overide_env_vars: bool = True) -> bool:
+    # Load dot env sets environmental values from a file, if the value already exists it will not be overwritten unless override is set to True.
+    # If we have multiple .env files then we need to apply the one which we want to take precedence last with overide.
+
+    # Order of precedence: .env file > environment variables > default values
+    # When developing, making a change to the config will not be reflected until the environment is restarted
+
+    # Set the env vars first, this is needed for the card.yaml to replace ENV variables
+    # NOTE: You need to adjust PROJECT_NAME to your package name for this to work, the exception is only for dev purposes
+    # This here checks if your package is installed, such as through pypi or through pip install -e  [.dev] for development. If it is then it'll go there and use the config files there as your default values.
+    try:
+        dotenv.load_dotenv(f"{PACKAGE_DIR}/config/config.default.env", override=False)
+    except Exception as e:
+        print(f"Error: {PACKAGE_DIR}/config/config.default.env does not exist")
+        return False
+
+    # 2. set values from file:
+    if os.path.isfile(config_path):
+        dotenv.load_dotenv(config_path, override=overide_env_vars)
+
+    return True
+
+# %% ../nbs/00_core.ipynb 15
+import importlib
+import importlib.util
+
+
+def get_config(config_path: str = None, overide_env_vars: bool = True) -> dict:
+    if config_path is None:
+        config_path = ""
+    # First sets environment with variables from config_path, then uses those variables to fill in appropriate values in the config.yaml file, the yaml file is then returned as a dict
+    # If you want user env variables to take precedence over the config.yaml file then set overide_env_vars to False
+    set_env_variables(config_path, overide_env_vars)
+
+    config: dict = envyaml.EnvYAML(
+        os.environ.get(
+            "CORE_YAML_CONFIG_FILE", f"{PACKAGE_DIR}/config/config.default.yaml"
+        ),
+        strict=False,
+    ).export()
+
+    return config
+
+# %% ../nbs/00_core.ipynb 17
+# create a os.PathLike object
+config = get_config(os.environ.get("CORE_CONFIG_FILE", ""))
+
+# %% ../nbs/00_core.ipynb 19
+def show_project_env_vars(config: dict) -> None:
+    # Prints out all the project environment variables
+    # This is useful for debugging and seeing what is being set
+    for k, v in config.items():
+        # If ENV var starts with PROJECTNAME_ then print
+        if k.startswith(config["CORE_PROJECT_VARIABLE_PREFIX"]):
+            print(f"{k}={v}")
+
+# %% ../nbs/00_core.ipynb 23
+import pandas as pd
+
+
+def get_samplesheet(sample_sheet_config: dict) -> pd.DataFrame:
+    # Load the sample sheet into a pandas dataframe
+    # If columns is not None then it will only load those columns
+    # If the sample sheet is a csv then it will load it as a csv, otherwise it will assume it's a tsv
+
+    # Expected sample_sheet_config:
+    # sample_sheet:
+    #   path: path/to/sample_sheet.tsv
+    #   delimiter: '\t' # Optional, will assume , for csv and \t otherwises
+    #   header: 0 # Optional, 0 indicates first row is header, None indicates no header
+    #   columns: ['column1', 'column2', 'column3'] # Optional, if not provided all columns will be used
+
+    # Example sample sheet:
+    # #sample_id	file_path	metadata1	metadata2
+    # Sample1	/path/to/sample1.fasta	value1	option1
+    # Sample2	/path/to/sample2.fasta	value2	option2
+    # Sample3	/path/to/sample3.fasta	value3	option1
+    # Sample4	/path/to/sample4.fasta	value1	option2
+    # Sample5	/path/to/sample5.fasta	value2	option1
+
+    # This function should also handle ensuring the sample sheet is in the correct format, such as ensuring the columns are correct and that the sample names are unique.
+    if not os.path.isfile(sample_sheet_config["path"]):
+        raise FileNotFoundError(f"File {sample_sheet_config['path']} does not exist")
+    if "delimiter" in sample_sheet_config:
+        delimiter = sample_sheet_config["delimiter"]
+    else:
+        # do a best guess based on file extension
+        delimiter = "," if sample_sheet_config["path"].endswith(".csv") else "\t"
+    header = 0
+    # if "header" in sample_sheet_config:
+    #     header = sample_sheet_config["header"]
+    # else:
+    #     # check if the first line starts with a #, if so lets assume it's a header otherwise assume there isn't one
+    #     with open(sample_sheet_config["path"], "r") as f:
+    #         first_line = f.readline()
+    #         header = 0 if first_line.startswith("#") else None
+    if "columns" in sample_sheet_config:
+        columns = sample_sheet_config[
+            "columns"
+        ]  # note the # for the first item needs to be stripped to compare to the columns
+    else:
+        columns = None  # implies all columns
+    try:
+        # note when we have a header the first column may begin with a #, so we need to remove it
+        df = pd.read_csv(
+            sample_sheet_config["path"],
+            delimiter=delimiter,
+            header=header,
+            comment=None,
+        )
+    except Exception as e:
+        print(
+            "Error: Could not load sample sheet into dataframe, you have a problem with your sample sheet or the configuration."
+        )
+        raise e
+
+    # Check the first header has a # in it, if so remove it for only that item
+    if df.columns[0].startswith("#"):
+        df.columns = [col.lstrip("#") for col in df.columns]
+    # Ensure the sample sheet has the correct columns
+    if columns is not None and not all([col in df.columns for col in columns]):
+        raise ValueError("Error: Sample sheet does not have the correct columns")
+    # also drop columns which are not needed
+    if columns is not None:
+        df = df[columns]
+
+    # Clean the df of any extra rows that can be caused by empty lines in the sample sheet
+    df = df.dropna(how="all")
+    return df
+
+# %% ../nbs/00_core.ipynb 24
+def update_results_dict(
+    old_results: dict,
+    new_results: dict,
+    old_duplicate_key_prefix: str = None,
+    new_duplicate_key_prefix: str = None,
+):
+    duplicate_keys = list(set(old_results.keys()) & set(new_results.keys()))
+    if len(duplicate_keys) == 0:
+        old_results.update(new_results)
+        return old_results
+    else:
+        if old_duplicate_key_prefix is None and new_duplicate_key_prefix is None:
+            raise ValueError(
+                "Provided dictionaries contain duplicate keys. old_duplicate_key_prefix and/or new_duplicate_key_prefix must be provided"
+            )
+        elif old_duplicate_key_prefix == new_duplicate_key_prefix:
+            raise ValueError(
+                "old_duplicate_key_prefix and new_duplicate_key_prefix cannot be identical"
+            )
+        else:
+            combined_dict = {}
+            if old_duplicate_key_prefix is None:
+                combined_dict.update(old_results)
+            else:
+                for key, value in old_results.items():
+                    if key in duplicate_keys:
+                        combined_dict.update(
+                            {f"{old_duplicate_key_prefix}{key}": value}
+                        )
+                    else:
+                        combined_dict.update({key: value})
+            if new_duplicate_key_prefix is None:
+                combined_dict.update(new_results)
+            else:
+                for key, value in new_results.items():
+                    if key in duplicate_keys:
+                        combined_dict.update(
+                            {f"{new_duplicate_key_prefix}{key}": value}
+                        )
+                    else:
+                        combined_dict.update({key: value})
+        return combined_dict
+
+
+def print_results_dict_to_tsv(
+    results_dict: dict, output_file: Path, sample_name: str = None
+) -> None:
+    if sample_name is None:
+        header = "\t".join(str(x) for x in results_dict.keys())
+        values = "\t".join(str(x) for x in results_dict.values())
+    else:
+        header = "sample_name\t" + "\t".join([str(x) for x in results_dict.keys()])
+        values = sample_name + "\t" + "\t".join([str(x) for x in results_dict.values()])
+    o = open(output_file, "w")
+    o.write(header + "\n")
+    o.write(values + "\n")
+    o.close()
+    return None

ssi_analysis_result_parsers/hello_world.py

@@ -0,0 +1,61 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/01_hello_world.ipynb.
+
+# %% auto 0
+__all__ = ['hello_world', 'cli']
+
+# %% ../nbs/01_hello_world.ipynb 6
+# That export there, it makes sure this code goes into the module.
+
+# standard libs
+import os
+import re
+
+# Common to template
+# add into settings.ini, requirements, package name is python-dotenv, for conda build ensure `conda config --add channels conda-forge`
+import dotenv  # for loading config from .env files, https://pypi.org/project/python-dotenv/
+import envyaml  # Allows to loads env vars into a yaml file, https://github.com/thesimj/envyaml
+import fastcore  # To add functionality related to nbdev development, https://github.com/fastai/fastcore/
+from fastcore import (
+    test,
+)
+from fastcore.script import (
+    call_parse,
+)  # for @call_parse, https://fastcore.fast.ai/script
+import json  # for nicely printing json and yaml
+
+# Project specific libraries
+
+# %% ../nbs/01_hello_world.ipynb 8
+from ssi_analysis_result_parsers import (
+    core,
+)
+
+# %% ../nbs/01_hello_world.ipynb 17
+def hello_world(name1: str, name2: str) -> str:
+    return f"Hello {name1} and {name2}!"
+
+# %% ../nbs/01_hello_world.ipynb 19
+from fastcore.script import call_parse
+
+
+@call_parse
+def cli(
+    name: str = None,  # A name
+    alternative_name: str = None,  # An alternative name
+    config_file: str = None,  # config file to set env vars from
+) -> None:
+    """
+    This will print Hello World! with your name
+    """
+    config = core.get_config(config_file)  # Set env vars and get config variables
+    if name is not None:
+        config["example"]["input"]["name"] = name
+    if alternative_name is not None:
+        config["example"]["input"]["alternative_name"] = alternative_name
+
+    print(
+        hello_world(
+            config["example"]["input"]["name"],
+            config["example"]["input"]["alternative_name"],
+        )
+    )